GitHub HTML Daily Trending Repositories

f/prompts.chat

f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source — self-host for your organization with complete privacy.

https://prompts.chat

prompts.chat

The world's largest open-source prompt library for AI
_{Works with ChatGPT, Claude, Gemini, Llama, Mistral, and more}

_{formerly known as Awesome ChatGPT Prompts}

🌐 Browse Prompts • 📖 Read the Book • 📄 View on GitHub • 🚀 Self-Host

_{🏆 Featured in Forbes · 🎓 Referenced by Harvard, Columbia · 📄 40+ academic citations · ❤️ Most liked dataset on Hugging Face
⭐ 143k+ GitHub stars · 🏅 GitHub Staff Pick · 🚀 First prompt library (Dec 2022)}

_{Loved by AI pioneers:}
_{Greg Brockman (OpenAI Co-Founder) · Wojciech Zaremba (OpenAI Co-Founder) · Clement Delangue (Hugging Face CEO) · Thomas Dohmke (Former GitHub CEO)}

What is this?

A curated collection of prompts for AI chat models. Originally created for ChatGPT, these prompts work great with any modern AI assistant.

Browse Prompts	Data Formats
prompts.chat	prompts.csv
PROMPTS.md	Hugging Face Dataset

Want to contribute? Add prompts at prompts.chat/prompts/new — they sync here automatically.

📖 The Interactive Book of Prompting

Learn prompt engineering with our free, interactive guide — 25+ chapters covering everything from basics to advanced techniques like chain-of-thought reasoning, few-shot learning, and AI agents.

Start Reading → (Source: https://github.com/f/prompts.chat/tree/main/src/content/book)

🎮 Prompting for Kids

An interactive, game-based adventure to teach children (ages 8-14) how to communicate with AI through fun puzzles and stories.

Start Playing →

🚀 Self-Hosting

Deploy your own private prompt library with custom branding, themes, and authentication.

Quick Start:

npx prompts.chat new my-prompt-library
cd my-prompt-library

Manual Setup:

git clone https://github.com/f/prompts.chat.git
cd prompts.chat
npm install && npm run setup

The setup wizard configures branding, theme, authentication (GitHub/Google/Azure AD), and features.

Recommended database: prompts.chat uses PostgreSQL. For a hosted database, we recommend Neon.

🔌 Integrations

CLI

npx prompts.chat

Claude Code Plugin

/plugin marketplace add f/prompts.chat
/plugin install prompts.chat@prompts.chat

📖 Plugin Documentation

MCP Server

Use prompts.chat as an MCP server in your AI tools.

Remote (recommended):

{
  "mcpServers": {
    "prompts.chat": {
      "url": "https://prompts.chat/api/mcp"
    }
  }
}

Local:

{
  "mcpServers": {
    "prompts.chat": {
      "command": "npx",
      "args": ["-y", "prompts.chat", "mcp"]
    }
  }
}

📖 MCP Documentation

💖 Sponsors

_{Built with Windsurf and Devin}
Become a Sponsor →

👥 Contributors

📜 License

This project is dual-licensed:

Source code and site-authored content is licensed under the MIT License, including the interactive book content in src/content/book.
Prompt content and data (prompts.csv, PROMPTS.md, user-submitted prompts) is dedicated to the public domain under CC0 1.0 Universal.

See LICENSE for details.

AhmadIbrahiim/Website-downloader

💡 Download the complete source code of any website (including all assets). [ Javascripts, Stylesheets, Images ] using Node.js

https://website-downloader.onrender.com

Complete Website Downloader 💾

Download the complete source code of any website (including all assets) 🔨.

👉 Live Demo: https://website-downloader.onrender.com

Description 📒

Website downloader works with wget and archiver to download all websites assets and compress then sends it back to the user through socket channel

wget params the being used

wget --mirror --convert-links --adjust-extension --page-requisites --no-parent http://example.org

Explanation of the various flags:

--mirror – Makes (among other things) the download recursive.
--convert-links – convert all the links (also to stuff like CSS stylesheets) to relative, so it will be suitable for offline viewing.
--adjust-extension – Adds suitable extensions to filenames (html or css) depending on their content-type.
--page-requisites – Download things like CSS style-sheets and images required to properly display the page offline.
--no-parent – When recursing do not ascend to the parent directory. It useful for restricting the download to only a portion of the site

Deploy on cloud providers

Requirements 📦

Node.js 16 or newer
wget on the PATH. The app shells out to it, and nothing will download without it:
- Debian/Ubuntu: apt install wget
- macOS: brew install wget
- Windows: winget install JernejSimoncic.Wget

How to run it 🤔

git clone https://github.com/AhmadIbrahiim/Website-downloader.git
cd Website-downloader
$ npm install
$ npm start
http://localhost:3000/

Optional settings

Variable	Default	What it does
`PORT`	`3000`	Port the server listens on
`DOWNLOAD_QUOTA`	`100m`	Size ceiling passed to wget, so one request cannot fill the disk
`DOWNLOAD_TIMEOUT_MS`	`300000`	How long a single download may run before it is stopped

How To Contribute:

Open Issue(s) with any bugs you notice.
Please create Pull Requests if you think it would be an added value towards our program.

Liked it ? You can buy a coffee:

Thank you,

Email: me@ahmed-ibrahim.com

https://www.ahmed-ibrahim.com

Jakubantalik/transitions.dev

Collection of the most essential transitions for web apps, skill for agents and Refine tool for agents

https://transitions.dev/

Transitions.dev

Transitions.dev is an interactive collection of reusable CSS transitions. Each card on the index page demonstrates a different interaction pattern and ships a copy-ready, portable CSS snippet for each.

Live site: https://transitions.dev/

Transitions

#	Name	What it shows
1	Card resize	Smooth card resize transition.
2	Number pop-in	Digit flip with blur and stagger.
3	Notification badge	Diagonal slide with spring pop-in.
4	Text states swap	Text swap transition with blur.
5	Menu dropdown	Origin-aware open / close transition.
6	Modal open / close	Modal transition with scale.
7	Panel reveal	Panel open / close transition.
8	Page side-by-side	Forward / back page transition.
9	Icon swap	Scale and blur icon swap.
10	Success check	Confirmation icon with fade, rotate, blur, Y-bob, and SVG path draw.
11	Avatar group hover	Hovered avatar springs up while neighbours follow with a falloff.
12	Error state shake	Input shake on validation error with auto-revert to neutral.

Each card has a copy button that emits a self-contained CSS snippet: semantic CSS custom properties on :root, the transition rules namespaced under t-* classes, and a @media (prefers-reduced-motion: reduce) guard — so you can paste the snippet into any project and apply it to any component without pulling in demo-specific markup or sizing.

Install with the CLI (npm)

Pull any transition into your project from the terminal — no manual copy:

npx transitions-dev add card-resize      # free, no account needed
npx transitions-dev add --free           # every free transition at once
npx transitions-dev list                 # see everything available

Pro transitions unlock after a passwordless browser sign-in (device flow — no API key in your terminal):

npx transitions-dev login                # opens the browser to confirm a code
npx transitions-dev add confetti-burst    # pulls the Pro CSS + React

CLI source: cli/ (published as the public transitions-dev package; transitions-pro is the old name and forwards to it — it holds no premium source; Pro recipes are fetched from the authenticated API).

Use as an agent skill

The same transitions are packaged as an installable agent skill so AI coding tools (Cursor, Claude Code, Codex, …) can apply them directly inside your project.

npx skills add Jakubantalik/transitions.dev

Skill source lives in skills/transitions-dev/ — SKILL.md, eighteen per-transition reference files (01-card-resize.md … 18-texts-reveal.md), and _root.css (the universal install block on its own).

The skill is generated from index.html so the snippets always match what the showcase site demonstrates. Re-run after editing the source site:

npm run build

build/extract.mjs parses PROTO_TEMPLATES and the :root { --pX-* } block out of index.html, then re-renders every file under skills/transitions-dev/ from the templates in build/templates/.

Refine tool

Refine is a live, agent-driven companion to the skill. One command drops a timeline + Refine panel onto your running app — no npm install, no source edits of your own — and every "Refine" click asks your coding agent to align the selected CSS/Motion transition to the transitions.dev motion tokens (or replace it with a transition from the library). Suggestions appear in a panel that slides in from the right; you pick which to apply as live, reversible overrides.

# inject the panel + start the local relay (deterministic suggestions work immediately)
npx transitions-refine live

# same, but also installs/wires the Cursor CLI so the relay answers with the LLM, persistently
npx transitions-refine live --llm

# remove the injected <script> tag again
npx transitions-refine stop

Without --llm, you can instead run /refine live in your editor to back the panel with the in-IDE agent. Source lives in refine/ and ships as the public npm package transitions-refine. See refine/README.md for the full flow and env knobs.

Files

index.html — main showcase page with all eighteen transitions and per-card "copy CSS" buttons.
prototypes.html — interactive playground for each transition with live tuning controls (durations, distances, easings).
skill.html — landing page for the agent skill (install instructions + side-by-side compare embed).
example.html — modal demo with a side-by-side "generic AI output" vs "with Transitions.dev skill" toggle, embedded inside skill.html as an iframe.
skills/transitions-dev/ — published skill payload (consumed by npx skills add).
refine/ — the Refine tool: a CLI that injects a live timeline + Refine panel and runs a local relay (published to npm as transitions-refine).
build/extract.mjs + build/templates/ — regenerator that keeps the skill in lockstep with index.html.
assets/ — icons, favicons, and the social-share OG image.
site.webmanifest, robots.txt, sitemap.xml — PWA/SEO metadata.

Run locally

python3 -m http.server 8765

Then open http://127.0.0.1:8765/.

htr-tech/zphisher

An automated phishing tool with 30+ templates. This Tool is made for educational purpose only ! Author will not be responsible for any misuse of this toolkit !

A beginners friendly, Automated phishing tool with 30+ templates.

Disclaimer

Any actions and or activities related to Zphisher is solely your responsibility. The misuse of this toolkit can result in criminal charges brought against the persons in question. The contributors will not be held responsible in the event any criminal charges be brought against any individuals misusing this toolkit to break the law.

This toolkit contains materials that can be potentially damaging or dangerous for social media. Refer to the laws in your province/country before accessing, using,or in any other way utilizing this in a wrong way.

This Tool is made for educational purposes only. Do not attempt to violate the law with anything contained here. If this is your intention, then Get the hell out of here!

It only demonstrates "how phishing works". You shall not misuse the information to gain unauthorized access to someones social media. However you may try out this at your own risk.

Features

Latest and updated login pages.
Beginners friendly
Multiple tunneling options
- Localhost
- Cloudflared
- LocalXpose
Mask URL support
Docker support

Installation

Just, Clone this repository -

git clone --depth=1 https://github.com/htr-tech/zphisher.git

Now go to cloned directory and run zphisher.sh -
```
$ cd zphisher
$ bash zphisher.sh
```
On first launch, It'll install the dependencies and that's it. Zphisher is installed.

Installation (Termux)

You can easily install zphisher in Termux by using tur-repo

$ pkg install tur-repo
$ pkg install zphisher
$ zphisher

A Note :

Termux discourages hacking .. So never discuss anything related to zphisher in any of the termux discussion groups. For more check : wiki

Installation via ".deb" file

Download .deb files from the Latest Release
If you are using termux then download the *_termux.deb

Install the .deb file by executing

apt install <your path to deb file>

$ dpkg -i <your path to deb file>
$ apt install -f

Run on Docker

Docker Image Mirror:

DockerHub :
```
docker pull htrtech/zphisher
```

GHCR :

docker pull ghcr.io/htr-tech/zphisher:latest

By using the wrapper script run-docker.sh

$ curl -LO https://raw.githubusercontent.com/htr-tech/zphisher/master/run-docker.sh
$ bash run-docker.sh

Temporary Container
```
docker run --rm -ti htrtech/zphisher
```
- Remember to mount the auth directory.

Dependencies

Zphisher requires following programs to run properly -

git
curl
php

All the dependencies will be installed automatically when you run Zphisher for the first time.

Tested on

Ubuntu
Debian
Arch
Manjaro
Fedora
Termux

:: Workflow ::

Find Me on:

Thanks to all contributors:

_1RaY-1	_{Aditya Shakya}	_{Ali Milani}	_AmnesiA	_KasRoudra	_{Moises Tapia}
_Mr.Derek	_{Mustakim Ahmed}	_sepp0	_TripleHat	_Yisus7u7

techchipnet/CamPhish

Grab cam shots & GPS location from target's phone front camera or PC webcam just sending a link.

CamPhish

Grab cam shots from target's phone front camera or PC webcam just sending a link.

What is CamPhish?

CamPhish is techniques to take cam shots of target's phone front camera or PC webcam. CamPhish Hosts a fake website on in built PHP server and uses ngrok & CloudFlare Tunnel to generate a link which we will forward to the target, which can be used on over internet. website asks for camera permission and if the target allows it, this tool grab camshots of target's device

A GPS location capture feature has been added.

Features

In this tool I added two automatic webpage templates for engaged target on webpage to get more picture of cam

Festival Wishing
Live YouTube TV
Online Meeting [Beta]
GPS Location Tracking

A cleanup script has been added to remove all unnecessary files and logs.

This Tool Tested On :

Kali Linux
Termux
MacOS
Ubuntu
Parrot Sec OS
Windows (WSL)

Installing and requirements

This tool require PHP for webserver, and wget for downloading dependencies. First run following command on your terminal

apt-get -y install php wget unzip

Installing (Kali Linux/Termux):

git clone https://github.com/techchipnet/CamPhish
cd CamPhish
bash camphish.sh

Clean logs & unnecessary files :

bash cleanup.sh

The cam files and saved location will also be removed.

Change Log:

Version: 2.0: Added GPS Location Tracking

Added: GPS location capturing functionality
Added: Google Maps integration for captured locations
Added: Location accuracy reporting
Added: Improved loading screen with location request

Version: 1.9: Enhanced architecture detection

Added: Improved architecture detection for all CPU types
Added: Better support for Apple Silicon (M1/M2/M3) Macs
Added: Automatic detection of ARM, ARM64, x86, and x86_64 architectures
Fixed: Windows compatibility improvements
Fixed: CloudFlare Tunnel download issues

Version: 1.8: Added CloudFlare Tunnel and removed Serveo

Added: CloudFlare Tunnel support for more reliable connections
Removed: Serveo tunnel (deprecated)
Fixed: Various code improvements and bug fixes

Version: 1.7: Fix and add support

fixed: termux failed to get home directory
Add support for Apple sillicon (M1/M2/M3 ARM64)
Add support for arm64 like Raspberry Pi

Version: 1.6: Fix ngrok direct link generate

Version: 1.5: Add new online meeting template

Version: 1.4: Ngrok authtoken update

Version: 1.3: Fix ngrok direct link

Important Notice

Unauthorized reuploading of this project is prohibited.

For More Video subcribe TechChip YouTube Channel

CamPhish is created to help in penetration testing and it's not responsible for any misuse or illegal purposes.

CamPhish is inspired by https://github.com/thelinuxchoice/ Big thanks to @thelinuxchoice

yogeshojha/rengine

reNgine is an automated reconnaissance framework for web applications with a focus on highly configurable streamlined recon process via Engines, recon data correlation and organization, continuous monitoring, backed by a database, and simple yet intuitive User Interface. reNgine makes it easy for penetration testers to gather reconnaissance with…

https://yogeshojha.github.io/rengine/

reNgine: The Ultimate Web Reconnaissance & Vulnerability Scanner 🚀

reNgine 2.2.0 is released!

reNgine 2.2.0 comes with bounty hub where you can sync and import your hackerone programs, in app notifications, chaos as subdomain enumeration tool, ability to upload multiple nuclei and gf patterns, support for regex in out of scope subdomain config, additional pdf report template and many more. Check out What's new in reNgine 2.2.0!

What is reNgine?

reNgine is your ultimate web application reconnaissance suite, designed to supercharge the recon process for security pros, pentesters, and bug bounty hunters. It is go-to web application reconnaissance suite that's designed to simplify and streamline the reconnaissance process for all the needs of security professionals, penetration testers, and bug bounty hunters. With its highly configurable engines, data correlation capabilities, continuous monitoring, database-backed reconnaissance data, and an intuitive user interface, reNgine redefines how you gather critical information about your target web applications.

Traditional reconnaissance tools often fall short in terms of configurability and efficiency. reNgine addresses these shortcomings and emerges as an excellent alternative to existing commercial tools.

reNgine was created to address the limitations of traditional reconnaissance tools and provide a better alternative, even surpassing some commercial offerings. Whether you're a bug bounty hunter, a penetration tester, or a corporate security team, reNgine is your go-to solution for automating and enhancing your information-gathering efforts.

Watch reNgine 2.0-jasper release trailer here!

Documentation

Detailed documentation available at https://rengine.wiki

About reNgine

reNgine is not an ordinary reconnaissance suite; it's a game-changer! We've turbocharged the traditional workflow with groundbreaking features that is sure to ease your reconnaissance game. reNgine redefines the art of reconnaissance with highly configurable scan engines, recon data correlation, continuous monitoring, GPT powered Vulnerability Report, Project Management and role based access control etc.

🦾 reNgine has advanced reconnaissance capabilities, harnessing a range of open-source tools to deliver a comprehensive web application reconnaissance experience. With its intuitive User Interface, it excels in subdomain discovery, pinpointing IP addresses and open ports, collecting endpoints, conducting directory and file fuzzing, capturing screenshots, and performing vulnerability scans. To summarize, it does end-to-end reconnaissance. With WHOIS identification and WAF detection, it offers deep insights into target domains. Additionally, reNgine also identifies misconfigured S3 buckets and find interesting subdomains and URLS, based on specific keywords to helps you identify your next target, making it a go-to tool for efficient reconnaissance.

🗃️ Say goodbye to recon data chaos! reNgine seamlessly integrates with a database, providing you with unmatched data correlation and organization. Forgot the hassle of grepping through json, txt or csv files. Plus, our custom query language lets you filter reconnaissance data effortlessly using natural language like operators such as filtering all alive subdomains with http_status=200 and also filter all subdomains that are alive and has admin in name http_status=200&name=admin

🔧 reNgine offers unparalleled flexibility through its highly configurable scan engines, based on a YAML-based configuration. It offers the freedom to create and customize recon scan engines based on any kind of requirement, users can tailor them to their specific objectives and preferences, from thread management to timeout settings and rate-limit configurations, everything is customizable. Additionally, reNgine offers a range of pre-configured scan engines right out of the box, including Full Scan, Passive Scan, Screenshot Gathering, and the OSINT Scan Engine. These ready-to-use engines eliminate the need for extensive manual setup, aligning perfectly with reNgine's core mission of simplifying the reconnaissance process and enabling users to effortlessly access the right reconnaissance data with minimal effort.

💎 Subscans: Subscan is a game-changing feature in reNgine, setting it apart as the only open-source tool of its kind to offer this capability. With Subscan, waiting for the entire pipeline to complete is a thing of the past. Now, users can swiftly respond to newfound discoveries during reconnaissance. Whether you've stumbled upon an intriguing subdomain and wish to conduct a focused port scan or want to delve deeper with a vulnerability assessment, reNgine has you covered.

📃 PDF Reports: In addition to its robust reconnaissance capabilities, reNgine goes the extra mile by simplifying the report generation process, recognizing the crucial role that PDF reports play in the realm of end-to-end reconnaissance. Users can effortlessly generate and customize PDF reports to suit their exact needs. Whether it's a Full Scan Report, Vulnerability Report, or a concise reconnaissance report, reNgine provides the flexibility to choose the report type that best communicates your findings. Moreover, the level of customization is unparalleled, allowing users to select report colors, fine-tune executive summaries, and even add personalized touches like company names and footers. With GPT integration, your reports aren't just a report, with remediation steps, and impacts, you get 360-degree view of the vulnerabilities you've uncovered.

🔖 Say Hello to Projects! reNgine 2.0 introduces a powerful addition that enables you to efficiently organize your web application reconnaissance efforts. With this feature, you can create distinct project spaces, each tailored to a specific purpose, such as personal bug bounty hunting, client engagements, or any other specialized recon task. Each projects will have separate dashboard and all the scan results will be separated from each project, while scan engines and configuration will be shared across all the projects.

⚙️ Roles and Permissions! In reNgine 2.0, we've taken your web application reconnaissance to a whole new level of control and security. Now, you can assign distinct roles to your team members—Sys Admin, Penetration Tester, and Auditor—each with precisely defined permissions to tailor their access and actions within the reNgine ecosystem.

🔐 Sys Admin: Sys Admin is a superuser that has permission to modify system and scan related configurations, scan engines, create new users, add new tools etc. Superuser can initiate scans and subscans effortlessly.
🔍 Penetration Tester: Penetration Tester will be allowed to modify and initiate scans and subscans, add or update targets, etc. A penetration tester will not be allowed to modify system configurations.
📊 Auditor: Auditor can only view and download the report. An auditor can not change any system or scan related configurations nor can initiate any scans or subscans.

🚀 GPT Vulnerability Report Generation: Get ready for the future of penetration testing reports with reNgine's groundbreaking feature: "GPT-Powered Report Generation"! With the power of OpenAI's GPT, reNgine now provides you with detailed vulnerability descriptions, remediation strategies, and impact assessments that read like they were written by a human security expert! But that's not all! Our GPT-driven reports go the extra mile by scouring the web for related news articles, blogs, and references, so you have a 360-degree view of the vulnerabilities you've uncovered. With reNgine 2.0 revolutionize your penetration testing game and impress your clients with reports that are not just informative but engaging and comprehensive with detailed analysis on impact assessment and remediation strategies.

🥷 GPT-Powered Attack Surface Generation: With reNgine 2.0, reNgine seamlessly integrates with GPT to identify the attacks that you can likely perform on a subdomain. By making use of reconnaissance data such as page title, open ports, subdomain name etc. reNgine can advise you the attacks you could perform on a target. reNgine will also provide you the rationale on why the specific attack is likely to be successful.

🧭 Continuous monitoring: Continuous monitoring is at the core of reNgine's mission, and it's robust continuous monitoring feature ensures that their targets are under constant scrutiny. With the flexibility to schedule scans at regular intervals, penetration testers can effortlessly stay informed about their targets. What sets reNgine apart is its seamless integration with popular notification channels such as Discord, Slack, and Telegram, delivering real-time alerts for newly discovered subdomains, vulnerabilities, or any changes in reconnaissance data.

Workflow

Features

Reconnaissance:
- Subdomain Discovery
- IP and Open Ports Identification
- Endpoints Discovery
- Directory/Files fuzzing
- Screenshot Gathering
- Vulnerability Scan
  - Nuclei
  - Dalfox XSS Scanner
  - CRLFuzzer
  - Misconfigured S3 Scanner
- WHOIS Identification
- WAF Detection
OSINT Capabilities
- Meta info Gathering
- Employees Gathering
- Email Address gathering
- Google Dorking for sensitive info and urls
Projects, create distinct project spaces, each tailored to a specific purpose, such as personal bug bounty hunting, client engagements, or any other specialized recon task.
Perform Advanced Query lookup using natural language alike and, or, not operations
Highly configurable YAML-based Scan Engines
Support for Parallel Scans
Support for Subscans
Recon Data visualization
GPT Vulnerability Description, Impact and Remediation generation
GPT Attack Surface Generator
Multiple Roles and Permissions to cater a team's need
Customizable Alerts/Notifications on Slack, Discord, and Telegram
Automatically report Vulnerabilities to HackerOne
Recon Notes and Todos
Clocked Scans (Run reconnaissance exactly at X Hours and Y minutes) and Periodic Scans (Runs reconnaissance every X minutes/- hours/days/week)
Proxy Support
Screenshot Gallery with Filters
Powerful recon data filtering with autosuggestions
Recon Data changes, find new/removed subdomains/endpoints
Tag targets into the Organization
Smart Duplicate endpoint removal based on page title and content length to cleanup the reconnaissance data
Identify Interesting Subdomains
Custom GF patterns and custom Nuclei Templates
Edit tool-related configuration files (Nuclei, Subfinder, Naabu, amass)
Add external tools from GitHub/Go
Interoperable with other tools, Import/Export Subdomains/Endpoints
Import Targets via IP and/or CIDRs
Report Generation
Toolbox: Comes bundled with most commonly used tools during penetration testing such as whois lookup, CMS detector, CVE lookup, etc.
Identification of related domains and related TLDs for targets
Find actionable insights such as Most Common Vulnerability, Most Common CVE ID, Most Vulnerable Target/Subdomain, etc.
You can now use local LLMs for Attack surface identification and vulnerability description (NEW: reNgine 2.1.0)
BountyHub, a central hub to manage your hackerone targets

Enterprise Support

Official enterprise-grade support, deployment, and maintenance services for reNgine are available through HailBytes.

You can also find the deep dive video on how to use and install reNgine from here reNgine Deep Dive by HailBytes

Quick Installation

Quick Setup for Ubuntu/VPS

Clone the repository

git clone https://github.com/yogeshojha/rengine && cd rengine

Configure the environment
```
nano .env
```
Ensure you change the POSTGRES_PASSWORD for security.
(Optional) For non-interactive install, set admin credentials in .env
```
DJANGO_SUPERUSER_USERNAME=yourUsername
DJANGO_SUPERUSER_EMAIL=YourMail@example.com
DJANGO_SUPERUSER_PASSWORD=yourStrongPassword
```
If you need to carry out a non-interactive installation, you can setup the login, email and password of the web interface admin directly from the .env file (instead of manually setting them from prompts during the installation process). This option can be interesting for automated installation (via ansible, vagrant, etc.).
- DJANGO_SUPERUSER_USERNAME: web interface admin username (used to login to the web interface).
- DJANGO_SUPERUSER_EMAIL: web interface admin email.
- DJANGO_SUPERUSER_PASSWORD: web interface admin password (used to login to the web interface).
Adjust Celery worker scaling in .env
```
MAX_CONCURRENCY=80
MIN_CONCURRENCY=10
```
MAX_CONCURRENCY: This parameter specifies the maximum number of reNgine's concurrent Celery worker processes that can be spawned. In this case, it's set to 80, meaning that the application can utilize up to 80 concurrent worker processes to execute tasks concurrently. This is useful for handling a high volume of scans or when you want to scale up processing power during periods of high demand. If you have more CPU cores, you will need to increase this for maximised performance.

MIN_CONCURRENCY: On the other hand, MIN_CONCURRENCY specifies the minimum number of concurrent worker processes that should be maintained, even during periods of lower demand. In this example, it's set to 10, which means that even when there are fewer tasks to process, at least 10 worker processes will be kept running. This helps ensure that the application can respond promptly to incoming tasks without the overhead of repeatedly starting and stopping worker processes.

These settings allow for dynamic scaling of Celery workers, ensuring that the application efficiently manages its workload by adjusting the number of concurrent workers based on the workload's size and complexity.

Here is the ideal value for MIN_CONCURRENCY and MAX_CONCURRENCY depending on the number of RAM your machine has:
- 4GB: MAX_CONCURRENCY=10
- 8GB: MAX_CONCURRENCY=30
- 16GB: MAX_CONCURRENCY=50
This is just an ideal value which developers have tested and tried out and works! But feel free to play around with the values. Maximum number of scans is determined by various factors, your network bandwidth, RAM, number of CPUs available. etc
Run the installation script:
```
sudo ./install.sh
```
For non-interactive install: sudo ./install.sh -n

Note: If needed, run chmod +x install.sh to grant execution permissions.

reNgine can now be accessed from https://127.0.0.1 or if you're on the VPS https://your_vps_ip_address

Unless you are on development branch, please do not access reNgine via any ports

Installation on Other Platforms

For Mac, Windows, or other systems, refer to our detailed installation guide https://reNgine.wiki/install/detailed/

Installation Video Tutorial

If you encounter any issues during installation or prefer a visual guide, one of our community members has created an excellent installation video for Kali Linux installation. You can find it here: https://www.youtube.com/watch?v=7OFfrU6VrWw

Please note: This is community-curated content and is not owned by reNgine. The installation process may change, so please refer to the official documentation for the most up-to-date instructions.

Updating

To update reNgine, run:
```
cd rengine &&  sudo ./update.sh
```
If update.sh lacks execution permissions, use:
```
sudo chmod +x update.sh
```

Community-Curated Videos

reNgine has a vibrant community that often creates helpful content about installation, features, and usage. Below is a collection of community-curated videos that you might find useful. Please note that these videos are not official reNgine content, and the information they contain may become outdated as reNgine evolves.

Always refer to the official documentation for the most up-to-date and accurate information. If you've created a video about reNgine and would like it featured here, please send a pull request updating this table.

Video Title	Language	Publisher	Date	Link
reNgine Installation on Kali Linux	English	Secure the Cyber World	2024-02-29	Watch
Resultados do ReNgine - Automação para Recon	Portuguese	Guia Anônima	2023-04-18	Watch
reNgine Introduction	Moroccan Arabic	Th3 Hacker News Bdarija	2021-07-27	Watch
Automated recon? ReNgine - Hacker Tools	English	Intigriti	2021-08-24	Watch

We appreciate the community's contributions in creating these resources.

Screenshots

Scan Results

General Usage

Initiating Subscan

Recon Data filtering

Report Generation

Toolbox

Adding Custom tool in Tools Arsenal

Contributing

We welcome contributions of all sizes! The open-source community thrives on collaboration, and your input is invaluable. Whether you're fixing a typo, improving UI, or adding new features, every contribution matters.

How you can contribute:

Code improvements
Documentation updates
Bug reports and fixes
New feature suggestions and implementations
UI/UX enhancements

To get started:

Check our Contributing Guide
Pick an open issue or propose a new one
Fork the repository and create your branch
Make your changes and submit a pull request

Remember, no contribution is too small. Your efforts help make reNgine better for everyone!

Submitting issues

When submitting issues, provide as much valuable information as possible to help developers resolve the problem quickly. Follow these steps to gather detailed debug information:

Enable Debug Mode:
- Edit web/entrypoint.sh in the project root
- Add export DEBUG=1 at the top of the file:
```
#!/bin/bash

export DEBUG=1

python3 manage.py migrate
python3 manage.py runserver 0.0.0.0:8000

exec "$@"
```
- Restart the web container: docker-compose restart web
View Debug Output:
- Run make logs to see the full stack trace
- Check the browser's developer console for XHR requests with 500 errors

Example Debug Output:

web_1          |   File "/usr/local/lib/python3.10/dist-packages/celery/app/task.py", line 411, in __call__
web_1          |     return self.run(*args, **kwargs)
web_1          | TypeError: run_command() got an unexpected keyword argument 'echo'

Submit Your Issue:
- Include the full stack trace in your GitHub issue
- Describe the steps to reproduce the problem
- Mention any relevant system information
Disable Debug Mode:
- Set DEBUG=0 in web/entrypoint.sh
- Restart the web container

By providing this detailed information, you significantly help developers identify and fix issues more efficiently.

First-time Open Source contributors

reNgine is an open-source project that welcomes contributors of all experience levels, including beginners. If you've never contributed to open source before, we encourage you to start here!

We're proud to support your first Pull Request (PR)
Check our open issues for starter-friendly tasks
Don't hesitate to ask questions in our community channels

Your contribution, no matter how small, is valuable to us.

reNgine Support

Before seeking support:

Please carefully read the README and documentation at rengine.wiki.
Most common questions and issues are addressed there.

If you still need assistance:

Do not use GitHub issues for support requests.
Join our community-maintained Discord channel.

Please note:

The Discord channel is maintained by the community.
While we strive to help, there's no guarantee of support or response time.
For confirmed bugs or feature requests, consider opening a GitHub issue.

Support and Sponsoring

reNgine is a passion project developed in my free time, alongside my day job. Your support helps keep this project alive and growing. Here's how you can contribute:

Add a GitHub Star to the project.
Share about reNgine on social media or in blog posts
Nominate me for GitHub Stars?
Use my DigitalOcean referral link to get $100 credit (I receive $25)

Your support, whether through donations or simply giving a star, tells me that reNgine is valuable to you. It motivates me to continue improving and adding features to make reNgine the go-to tool for reconnaissance.

Thank you for your support!

Reporting Security Vulnerabilities

We appreciate your efforts to responsibly disclose your findings and will make every effort to acknowledge your contributions.

To report a security vulnerability, please follow these steps:

Do Not disclose the vulnerability publicly on GitHub issues or any other public forum.
Go to the Security tab of the reNgine repository.
Click on "Report a vulnerability" to open GitHub's private vulnerability reporting form.
Provide a detailed description of the vulnerability, including:
- Steps to reproduce
- Potential impact
- Any suggested fixes or mitigations (if you have them)
I will review your report and respond as quickly as possible, usually within 48-72 hours.
Please allow some time to investigate and address the vulnerability before disclosing it to others.

We are committed to working with security researchers to verify and address any potential vulnerabilities reported to us. After fixing the issue, we will publicly acknowledge your responsible disclosure, unless you prefer to remain anonymous.

Thank you for helping to keep reNgine and its users safe!

License

Distributed under the GNU GPL v3 License. See LICENSE for more information.

Note: Parts of this README were written or refined using AI language models.

tinkerhub/useless_project_temp

[Project Name] 🎯

Basic Details

Team Name: [Name]

Team Members

Team Lead: [Name] - [College]
Member 2: [Name] - [College]
Member 3: [Name] - [College]

Project Description

[2-3 lines about what your project does]

The Problem (that doesn't exist)

[What ridiculous problem are you solving?]

The Solution (that nobody asked for)

[How are you solving it? Keep it fun!]

Technical Details

Technologies/Components Used

For Software:

[Languages used]
[Frameworks used]
[Libraries used]
[Tools used]

For Hardware:

[List main components]
[List specifications]
[List tools required]

Implementation

For Software:

Installation

[commands]

Run

[commands]

Project Documentation

For Software:

Screenshots (Add at least 3)

![Screenshot1](Add screenshot 1 here with proper name) Add caption explaining what this shows

![Screenshot2](Add screenshot 2 here with proper name) Add caption explaining what this shows

![Screenshot3](Add screenshot 3 here with proper name) Add caption explaining what this shows

Diagrams

![Workflow](Add your workflow/architecture diagram here) Add caption explaining your workflow

For Hardware:

Schematic & Circuit

![Circuit](Add your circuit diagram here) Add caption explaining connections

![Schematic](Add your schematic diagram here) Add caption explaining the schematic

Build Photos

![Components](Add photo of your components here) List out all components shown

![Build](Add photos of build process here) Explain the build steps

![Final](Add photo of final product here) Explain the final build

Project Demo

Video

[Add your demo video link here] Explain what the video demonstrates

Additional Demos

[Add any extra demo materials/links]

Team Contributions

[Name 1]: [Specific contributions]
[Name 2]: [Specific contributions]
[Name 3]: [Specific contributions]

Made with ❤️ at TinkerHub Useless Projects

apna-college/Delta

Delta

Please use this repo to download your in-class starter codes.

ossu/computer-science

🎓 Path to a free self-taught education in Computer Science!

https://cs.ossu.dev

Open Source Society University

Path to a free self-taught education in Computer Science!

Summary

The OSSU curriculum is a complete education in computer science using online materials. It's not merely for career training or professional development. It's for those who want a proper, well-rounded grounding in concepts fundamental to all computing disciplines, and for those who have the discipline, will, and (most importantly!) good habits to obtain this education largely on their own, but with support from a worldwide community of fellow learners.

It is designed according to the degree requirements of undergraduate computer science majors, minus general education (non-CS) requirements, as it is assumed most of the people following this curriculum are already educated outside the field of CS. The courses themselves are among the very best in the world, often coming from Harvard, Princeton, MIT, etc., but specifically chosen to meet the following criteria.

Courses must:

Be open for enrollment
Run regularly (ideally in self-paced format, otherwise running multiple times per year)
Be of generally high quality in teaching materials and pedagogical principles
Match the curricular standards of the CS 2013: Curriculum Guidelines for Undergraduate Degree Programs in Computer Science

When no course meets the above criteria, the coursework is supplemented with a book. When there are courses or books that don't fit into the curriculum but are otherwise of high quality, they belong in extras/courses or extras/readings.

Organization. The curriculum is designed as follows:

Intro CS: for students to try out CS and see if it's right for them
Core CS: corresponds roughly to the first three years of a computer science curriculum, taking classes that all majors would be required to take
Advanced CS: corresponds roughly to the final year of a computer science curriculum, taking electives according to the student's interests
Final Project: a project for students to validate, consolidate, and display their knowledge, to be evaluated by their peers worldwide

Duration. It is possible to finish within about 2 years if you plan carefully and devote roughly 20 hours/week to your studies. Learners can use this spreadsheet to estimate their end date. Make a copy and input your start date and expected hours per week in the Timeline sheet. As you work through courses you can enter your actual course completion dates in the Curriculum Data sheet and get updated completion estimates.

Warning: While the spreadsheet is a useful tool to estimate the time you need to complete this curriculum, it may not always be up-to-date with the curriculum. Use the OSSU CS website or the repo to see what courses to do.

Cost. All or nearly all course material is available for free. However, some courses may charge money for assignments/tests/projects to be graded. Note that both Coursera and edX offer financial aid.

Decide how much or how little to spend based on your own time and budget; just remember that you can't purchase success!

Process. Students can work through the curriculum alone or in groups, in order or out of order.

We recommend doing all courses in Core CS, only skipping a course when you are certain that you've already learned the material previously.
For simplicity, we recommend working through courses (especially Core CS) in order from top to bottom. Some students choose to study multiple courses at a time in order to vary the material they are working on in a day/week. A popular option is to take the math courses in parallel with the introductory courses. Course prerequisites are listed to help you determine if you are prepared for a given course.
Courses in Advanced CS are electives. Choose one subject (e.g. Advanced programming) you want to become an expert in and take all the courses under that heading. You can also create your own custom subject; the Discord community may provide feedback on your planned subject.

Content policy. If you plan on showing off some of your coursework publicly, you must share only files that you are allowed to. Respect the code of conduct that you signed in the beginning of each course!

How to contribute

Getting help (Details about our FAQ and chatroom)

Community

We have a Discord server! This should be your first stop to talk with other OSSU students. Why don't you introduce yourself right now? Join the OSSU Discord
You can also interact through GitHub issues. If there is a problem with a course, or a change needs to be made to the curriculum, this is the place to start the conversation. Read more here.
Add Open Source Society University to your Linkedin profile!

Warning: There are a few third-party/deprecated/outdated material that you might find when searching for OSSU. We recommend you to ignore them, and only use the OSSU CS website or OSSU CS Github Repo. Some known outdated materials are:

An unmaintained and deprecated firebase app. Read more in the FAQ.

An unmaintained and deprecated trello board

Third-party notion templates

Curriculum

Prerequisites

Core CS assumes the student has already taken high school math, including algebra, geometry, and pre-calculus.
Advanced CS assumes the student has already taken the entirety of Core CS and is knowledgeable enough now to decide which electives to take.
Note that Advanced systems assumes the student has taken a basic physics course (e.g. AP Physics in high school).

Intro CS

This course will introduce you to the world of computer science and programming. This course gives you a flavor of the material to come. If you finish the course wanting more, Computer Science is likely for you!

Topics covered: computation imperative programming basic data structures and algorithms and more

Courses	Duration	Effort	Prerequisites	Discussion
Introduction to Computer Science and Programming using Python	14 weeks	6-10 hours/week	high school algebra	chat

Core CS

All coursework under Core CS is required, unless otherwise indicated.

Core programming

Topics covered: functional programming design for testing program requirements common design patterns unit testing object-oriented design static typing dynamic typing ML-family languages (via Standard ML) Lisp-family languages (via Racket) Ruby and more

Courses	Duration	Effort	Prerequisites	Discussion
Systematic Program Design	13 weeks	8-10 hours/week	none	chat: part 1 / part 2
Class-based Program Design	13 weeks	5-10 hours/week	Systematic Program Design, High School Math	chat
Programming Languages	11 weeks	4-8 hours/week	Systematic Program Design	chat
Object-Oriented Design	13 weeks	5-10 hours/week	Class-based Program Design	chat
Software Architecture	4 weeks	2-5 hours/week	Object Oriented Design	chat

Core math

Discrete math (Math for CS) is a prerequisite and closely related to the study of algorithms and data structures. Calculus both prepares students for discrete math and helps students develop mathematical maturity.

Topics covered: discrete mathematics mathematical proofs basic statistics O-notation discrete probability and more

Courses	Duration	Effort	Notes	Prerequisites	Discussion
Calculus 1A: Differentiation (alternative)	13 weeks	6-10 hours/week	The alternate covers this and the following 2 courses	high school math	chat
Calculus 1B: Integration	13 weeks	5-10 hours/week	-	Calculus 1A	chat
Calculus 1C: Coordinate Systems & Infinite Series	6 weeks	5-10 hours/week	-	Calculus 1B	chat
Mathematics for Computer Science (alternative)	13 weeks	5 hours/week	2015/2019 solutions 2010 solutions 2005 solutions.	Calculus 1C	chat

CS Tools

Understanding theory is important, but you will also be expected to create programs. There are a number of tools that are widely used to make that process easier. Learn them now to ease your future work writing programs.

Topics covered: terminals and shell scripting vim command line environments version control and more

Courses	Duration	Effort	Prerequisites	Discussion
The Missing Semester of Your CS Education	2 weeks	12 hours/week	-	chat

Core systems

Topics covered: procedural programming manual memory management boolean algebra gate logic memory computer architecture assembly machine language virtual machines high-level languages compilers operating systems network protocols and more

Courses	Duration	Effort	Additional Text / Assignments	Prerequisites	Discussion
Build a Modern Computer from First Principles: From Nand to Tetris (alternative)	6 weeks	7-13 hours/week	-	C-like programming language	chat
Build a Modern Computer from First Principles: Nand to Tetris Part II	6 weeks	12-18 hours/week	-	one of these programming languages, From Nand to Tetris Part I	chat
Operating Systems: Three Easy Pieces	10-12 weeks	6-10 hours/week	-	Nand to Tetris Part II	chat
Computer Networking: a Top-Down Approach	8 weeks	4–12 hours/week	Wireshark Labs	algebra, probability, basic CS	chat

Core theory

Topics covered: divide and conquer sorting and searching randomized algorithms graph search shortest paths data structures greedy algorithms minimum spanning trees dynamic programming NP-completeness and more

Courses	Duration	Effort	Prerequisites	Discussion
Algorithms: Design and Analysis, Part 1 (alternative)	8 weeks	4-8 hours/week	any programming language, Mathematics for Computer Science	chat
Algorithms: Design and Analysis, Part 2	8 weeks	4-8 hours/week	Algorithms Part 1	chat

Core security

Topics covered Confidentiality, Integrity, Availability Secure Design Defensive Programming Threats and Attacks Network Security Cryptography and more

Courses	Duration	Effort	Prerequisites	Discussion
Cybersecurity Fundamentals	8 weeks	10-12 hours/week	-	chat
Principles of Secure Coding	4 weeks	4 hours/week	-	chat
Identifying Security Vulnerabilities	4 weeks	4 hours/week	-	chat

Choose one of the following:

Courses	Duration	Effort	Prerequisites	Discussion
Identifying Security Vulnerabilities in C/C++ Programming	4 weeks	5 hours/week	-	chat
Exploiting and Securing Vulnerabilities in Java Applications	4 weeks	5 hours/week	-	chat

Core applications

Topics covered: Agile methodology REST software specifications refactoring relational databases transaction processing data modeling neural networks supervised learning unsupervised learning OpenGL ray tracing and more

Courses	Duration	Effort	Prerequisites	Discussion
Databases: Modeling and Theory	2 weeks	10 hours/week	core programming	chat
Databases: Relational Databases and SQL	2 weeks	10 hours/week	core programming	chat
Databases: Semistructured Data	2 weeks	10 hours/week	core programming	chat
Machine Learning	11 weeks	9 hours/week	Basic coding	chat
Computer Graphics (alternative)	6 weeks	12 hours/week	C++ or Java, Basic Linear Algebra	chat
Software Engineering: Introduction (alternative)	6 weeks	8-10 hours/week	Core Programming, and a sizable project	chat

Core ethics

Topics covered: Social Context Analytical Tools Professional Ethics Intellectual Property Privacy and Civil Liberties and more

Courses	Duration	Effort	Prerequisites	Discussion
Ethics, Technology and Engineering	9 weeks	2 hours/week	none	chat
Introduction to Intellectual Property	4 weeks	2 hours/week	none	chat
Data Privacy Fundamentals	3 weeks	3 hours/week	none	chat

Advanced CS

After completing every required course in Core CS, students should choose a subset of courses from Advanced CS based on interest. Not every course from a subcategory needs to be taken. But students should take every course that is relevant to the field they intend to go into.

Advanced programming

Topics covered: debugging theory and practice goal-oriented programming parallel computing object-oriented analysis and design UML large-scale software architecture and design and more

Courses	Duration	Effort	Prerequisites
Parallel Programming	4 weeks	6-8 hours/week	Scala programming
Compilers	9 weeks	6-8 hours/week	none
Introduction to Haskell	14 weeks	-	-
Learn Prolog Now! (alternative)*	12 weeks	-	-
Software Debugging	8 weeks	6 hours/week	Python, object-oriented programming
Software Testing	4 weeks	6 hours/week	Python, programming experience

(*) book by Blackburn, Bos, Striegnitz (compiled from source, redistributed under CC license)

Advanced systems

Topics covered: digital signaling combinational logic CMOS technologies sequential logic finite state machines processor instruction sets caches pipelining virtualization parallel processing virtual memory synchronization primitives system call interface and more

Courses	Duration	Effort	Prerequisites	Notes
Computation Structures 1: Digital Circuits alternative 1 alternative 2	10 weeks	6 hours/week	Nand2Tetris II	Alternate links contain all 3 courses.
Computation Structures 2: Computer Architecture	10 weeks	6 hours/week	Computation Structures 1	-
Computation Structures 3: Computer Organization	10 weeks	6 hours/week	Computation Structures 2	-

Advanced theory

Topics covered: formal languages Turing machines computability event-driven concurrency automata distributed shared memory consensus algorithms state machine replication computational geometry theory propositional logic relational logic Herbrand logic game trees and more

Courses	Duration	Effort	Prerequisites
Theory of Computation (alternative)	13 weeks	10 hours/week	Mathematics for Computer Science, logic, algorithms
Computational Geometry	16 weeks	8 hours/week	algorithms, C++
Algorithmic Game Theory	10 weeks	12 hours/week	Core Theory

Advanced Information Security

Courses	Duration	Effort	Prerequisites
Web Security Fundamentals	5 weeks	4-6 hours/week	understanding basic web technologies
Security Governance & Compliance	3 weeks	3 hours/week	-
Digital Forensics Concepts	3 weeks	2-3 hours/week	Core Security
Secure Software Development: Requirements, Design, and Reuse	7 weeks	1-2 hours/week	Core Programming and Core Security
Secure Software Development: Implementation	7 weeks	1-2 hours/week	Secure Software Development: Requirements, Design, and Reuse
Secure Software Development: Verification and More Specialized Topics	7 weeks	1-2 hours/week	Secure Software Development: Implementation

Advanced math

Courses	Duration	Effort	Prerequisites	Discussion
Essence of Linear Algebra	-	-	high school math	chat
Linear Algebra	14 weeks	12 hours/week	corequisite: Essence of Linear Algebra	chat
Introduction to Numerical Methods	14 weeks	12 hours/week	Linear Algebra	chat
Introduction to Formal Logic	10 weeks	4-8 hours/week	Set Theory	chat
Probability	15 weeks	5-10 hours/week	Differentiation and Integration	chat

Final project

Part of learning is doing. The assignments and exams for each course are to prepare you to use your knowledge to solve real-world problems.

After you've completed Core CS and the parts of Advanced CS relevant to you, you should identify a problem that you can solve using the knowledge you've acquired. You can create something entirely new, or you can improve some tool/program that you use and wish were better.

Students who would like more guidance in creating a project may choose to use a series of project oriented courses. Here is a sample of options (many more are available, at this point you should be capable of identifying a series that is interesting and relevant to you):

Courses	Duration	Effort	Prerequisites
Fullstack Open	12 weeks	15 hours/week	programming
Modern Robotics	26 weeks	2-5 hours/week	freshman-level physics, linear algebra, calculus, linear ordinary differential equations
Data Mining (Specialization)	30 weeks	2-5 hours/week	machine learning
Big Data (Specialization)	30 weeks	3-5 hours/week	none
Internet of Things (Specialization)	30 weeks	1-5 hours/week	strong programming
Cloud Computing (Specialization)	30 weeks	2-6 hours/week	C++ programming
Data Science (Specialization)	43 weeks	1-6 hours/week	none
Functional Programming in Scala (Specialization)	29 weeks	4-5 hours/week	One year programming experience
Game Design and Development with Unity 2020 (Specialization)	6 months	5 hours/week	programming, interactive design

Congratulations

After completing the requirements of the curriculum above, you will have completed the equivalent of a full bachelor's degree in Computer Science. Congratulations!

What is next for you? The possibilities are boundless and overlapping:

Look for a job as a developer!
Check out the readings for classic books you can read that will sharpen your skills and expand your knowledge.
Join a local developer meetup (e.g. via meetup.com).
Pay attention to emerging technologies in the world of software development:
- Explore the actor model through Elixir, a new functional programming language for the web based on the battle-tested Erlang Virtual Machine!
- Explore borrowing and lifetimes through Rust, a systems language which achieves memory- and thread-safety without a garbage collector!
- Explore dependent type systems through Idris, a new Haskell-inspired language with unprecedented support for type-driven development.

Code of conduct

OSSU's code of conduct.

How to show your progress

Fork the GitHub repo into your own GitHub account and put ✅ next to the stuff you've completed as you complete it. This can serve as your kanban board and will be faster to implement than any other solution (giving you time to spend on the courses).

Team

Eric Douglas: founder of OSSU
Josh Hanson: lead technical maintainer
Waciuma Wanjohi: lead academic maintainer
Contributors

ultrasecurity/Storm-Breaker

Social engineering tool [Access Webcam & Microphone & Location Finder] With {Py,JS,PHP}

https://ultraamooz.com

A Tool With Attractive Capabilities.

Features:

Obtain Device Information Without Any Permission !
Access Location [SMARTPHONES]
Access Webcam
Access Microphone

Update Log:

Second (latest) Update on November 4th , 2022 .
The overall structure of the tool is programmed from the beginning and is available as a web panel (in previous versions, the tool was available in the command line).
Previous version's bugs fixed !
Auto-download Ngrok Added !
The templates have been optimized !
Logs can be downloaded (NEW) !
Clear log Added !
It can be uploaded on a personal host (you won't have the Ngork problems anymore)
You can start and stop the listener anytime ! (At will)
Beautified user interface (NEW) !

We have deleted Ngrok in the new version of Storm breaker and entrusted the user with running and sharing the localhost . So please note that Storm breaker runs a localhost for you and you have to start the Ngrok on your intended port yourself .

Attention! :

This version can be run on both local host and your personal domain and host . However , you can use it for both situations. If your country has suspended the Ngrok service, or your country's banned Ngrok, or your victim can't open the Ngrok link (for the reasons such as : He sees such a link as suspicious, Or if this service is suspended in his country) We suggest using the tool on your personal host and domain .

Default username and password:

username : admin
password : admin
You can edit the config.php file to change the username and password .

Dependencies

Storm Breaker requires following programs to run properly -

php
python3
git
Ngrok

Platforms Tested

Kali Linux 2022
macOS Big Sur / M1
Termux (android)
Personal host (direct admin and cPanel)

Installation On Kali Linux

git clone https://github.com/ultrasecurity/Storm-Breaker
cd Storm-Breaker
sudo bash install.sh
sudo python3 -m pip install -r requirements.txt
sudo python3 st.py

how to run personal host 👇

Zip the contents of the storm-web folder completely and upload it to the public_html path .

Note that the tool should not be opened in a path like this > yourdomain.com/st-web Instead , it should be opened purely in the public_html path (i.e. : don't just zip the storm-web folder itself, but manually zip its contents (the index.php file and other belongings should be in the public_html path)

Attention!:

Note that to use this tool on your Localhost , You also need SSL . Because many of the tool's capabilities require SSL .

Attention!:

To run ngrok on termux you need to enable your personal hotspot and cellular network.

kubernetes/website

Kubernetes website and documentation repo:

https://kubernetes.io

The Kubernetes documentation

This repository contains the assets required to build the Kubernetes website and documentation. We're glad that you want to contribute!

Using this repository

You can run the website locally using Hugo (Extended version), or you can run it in a container runtime. We strongly recommend using the container runtime, as it gives deployment consistency with the live website.

Prerequisites

To use this repository, you need the following installed locally:

npm
Go
Hugo (Extended version)
A container runtime, like Docker.

Note

Make sure to install the Hugo extended version specified by the HUGO_VERSION environment variable in the netlify.toml file.

Before you start, install the dependencies. Clone the repository and navigate to the directory:

git clone https://github.com/kubernetes/website.git
cd website

The Kubernetes website uses the Docsy Hugo theme, which can be installed via npm. You can also download a pre-configured development container image that includes Hugo and Docsy. Additionally, a Git submodule is used for tools that generate the reference documentation.

Windows

# fetch submodule dependencies
git submodule update --init --recursive --depth 1

Linux / other Unix

# fetch submodule dependencies
make module-init

Running the website using a container

To build the site in a container, run the following:

# You can set $CONTAINER_ENGINE to the name of any Docker-like container tool

# Render the full website
make container-serve

# Render only a specific language segment (e.g., English)
make container-serve segments=en

# Render multiple languages (e.g., English and Korean)
make container-serve segments=en,ko

💡 Tip: Using Hugo segments speeds up local preview builds, by rendering only selected language(s).

If you see errors, it probably means that the Hugo container did not have enough computing resources available. To solve it, increase the amount of allowed CPU and memory usage for Docker on your machine (macOS and Windows).

Open up your browser to http://localhost:1313 to view the website. As you make changes to the source files, Hugo updates the website and forces a browser refresh.

Running the website locally using Hugo

To install dependencies, deploy and test the site locally, run:

For macOS and Linux

npm ci

# Render the full site (default)
make serve

# Render only a specific language segment
make serve segments=en

# Render multiple language segments
make serve segments=en,ko

💡 Tip: Hugo segments are defined in hugo.toml and allow faster rendering by limiting the scope to specific language(s).

For Windows (PowerShell)

npm ci
hugo.exe server --config hugo.toml,hugo.server.toml --buildFuture --environment development

This will start the local Hugo server on port 1313. Open up your browser to http://localhost:1313 to view the website. As you make changes to the source files, Hugo updates the website and forces a browser refresh.

Building the API reference pages

The API reference pages located in content/en/docs/reference/kubernetes-api are built from the Swagger specification, also known as OpenAPI specification, using https://github.com/kubernetes-sigs/reference-docs/tree/master/gen-resourcesdocs.

To update the reference pages for a new Kubernetes release follow these steps:

Pull in the api-ref-generator submodule:

git submodule update --init --recursive --depth 1

Update the Swagger specification:

curl 'https://raw.githubusercontent.com/kubernetes/kubernetes/master/api/openapi-spec/swagger.json' > api-ref-assets/api/swagger.json

In api-ref-assets/config/, adapt the files toc.yaml and fields.yaml to reflect the changes of the new release.
Next, build the pages:
```
make api-reference
```
You can test the results locally by building and serving the site from a container:
```
make container-serve
```
In a web browser, go to http://localhost:1313/docs/reference/kubernetes-api/ to view the API reference.
When all changes of the new contract are reflected into the configuration files toc.yaml and fields.yaml, create a Pull Request with the newly generated API reference pages.

Troubleshooting

If you experience any issues with running website locally, please refer to the Troubleshooting section of the contributing documentation.

Get involved with SIG Docs

Learn more about SIG Docs Kubernetes community and meetings on the community page.

You can also reach the maintainers of this project at:

Contributing to the docs

You can click the Fork button in the upper-right area of the screen to create a copy of this repository in your GitHub account. This copy is called a fork. Make any changes you want in your fork, and when you are ready to send those changes to us, go to your fork and create a new pull request to let us know about it.

Once your pull request is created, a Kubernetes reviewer will take responsibility for providing clear, actionable feedback. As the owner of the pull request, it is your responsibility to modify your pull request to address the feedback that has been provided to you by the Kubernetes reviewer.

Also, note that you may end up having more than one Kubernetes reviewer provide you feedback or you may end up getting feedback from a Kubernetes reviewer that is different than the one initially assigned to provide you feedback.

Furthermore, in some cases, one of your reviewers might ask for a technical review from a Kubernetes tech reviewer when needed. Reviewers will do their best to provide feedback in a timely fashion but response time can vary based on circumstances.

For more information about contributing to the Kubernetes documentation, see:

New contributor ambassadors

If you need help at any point when contributing, the New Contributor Ambassadors are a good point of contact. These are SIG Docs approvers whose responsibilities include mentoring new contributors and helping them through their first few pull requests. The best place to contact the New Contributors Ambassadors would be on the Kubernetes Slack. Current New Contributors Ambassadors for SIG Docs:

Name	Slack	GitHub
Sreeram Venkitesh	@sreeram.venkitesh	@sreeram-venkitesh

Localization READMEs

Language	Language
Bengali	Korean
Chinese	Polish
French	Portuguese
German	Russian
Hindi	Spanish
Indonesian	Ukrainian
Italian	Vietnamese
Japanese

Code of conduct

Participation in the Kubernetes community is governed by the CNCF Code of Conduct.

Thank you

Kubernetes thrives on community participation, and we appreciate your contributions to our website and our documentation!

horilla/horilla-hr

Horilla is a free and open source HR software.

https://www.horilla.com/

Horilla HRMS

Important

2.0 is now this repository’s default branch. Use it to run or deploy Horilla (a plain git clone checks it out). To contribute code, branch from and open PRs against dev/v2.0 — GitHub still pre-selects 2.0 as the PR base, so switch it manually. v1 (1.0/master) is deprioritized, with fixes considered case-by-case rather than on a guaranteed schedule. Full details → Discussion #1127.

A comprehensive, free, and open-source Human Resource Management System (HRMS) designed to streamline HR operations and enhance organizational efficiency.

🚀 Features

Core HR Modules

👥 Employee Management - Centralized workforce data with LDAP integration
🎯 Recruitment - End-to-end hiring process from job posting to onboarding
📋 Onboarding & Offboarding - Structured workflows for employee lifecycle
⏰ Attendance & Time Tracking - Biometric integration and automated check-in/out
🏖️ Leave Management - Policy enforcement, approvals, and balance tracking
💰 Payroll - Automated salary processing, tax calculations, and compliance
📊 Performance Management - Goal setting, reviews, and continuous feedback
🏢 Asset Management - Track and manage company resources
🎫 Helpdesk - Centralized HR support and ticketing system

📋 Table of Contents

🌳 Which Branch Do I Want?

2.0 (default) — the latest stable v2 snapshot. This is what a plain git clone gives you. Use it to run or deploy Horilla.
dev/v2.0 — the active integration branch. If you want to contribute code, branch from and open PRs against this, not 2.0.
1.0/master — v1, now deprioritized (fixes considered case-by-case, no guaranteed schedule). Not deleted, but no longer where active development happens.

See Discussion #1127 for full background on this transition.

⚡ Quick Start

Using the official Docker image (Recommended)

Published for linux/amd64 and linux/arm64 as horilla/horilla-hr:

docker pull horilla/horilla-hr:2.1.5

Pin an exact version in production rather than latest, so a deploy cannot pick up a new release unattended; see all tags for the current one. The repository overview documents every environment variable, the volumes to back up, and a working Compose file.

First boot applies the full migration set before the web server binds, which takes a few minutes on an empty database.

Building from source with Docker

# Clone the repository (defaults to the stable 2.0 branch)
git clone https://github.com/horilla/horilla-hr.git
cd horilla-hr

# Start with Docker Compose
docker compose up -d

# Access the application
open http://localhost:8000

Full Docker guide, including production deployment: docker/README.md

Manual Installation

Requires Python 3.12, 3.13 or 3.14, and pip 21.3 or newer. Python 3.15 is not usable yet: spacy declares Requires-Python <3.15 and is imported at module scope, so the app cannot start on it.

# Clone and setup (defaults to the stable 2.0 branch)
git clone https://github.com/horilla/horilla-hr.git
cd horilla-hr

# Create virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Upgrade pip FIRST. A venv inherits the system pip, and an older one does not
# recognise current manylinux wheel tags -- it then tries to compile packages
# like cryptography and PyMuPDF from source, which needs a C toolchain most
# machines do not have. The Docker build already does this; do the same here.
python -m pip install --upgrade pip

# Install dependencies
pip install -r requirements.txt

# Setup environment
cp .env.dist .env
# Edit .env with your configuration

# Initialize database
python manage.py migrate
python manage.py compilemessages
python manage.py collectstatic

# Run development server
python manage.py runserver

🛠 Installation

For detailed installation instructions, configuration guides, and platform-specific setup instructions, please visit our comprehensive documentation:

📖 Complete Installation Guide → docs.horilla.com/technical/v2.0/

Our documentation includes:

Step-by-step installation for all supported platforms
Database configuration guides
Environment setup instructions
Production deployment best practices
Troubleshooting common issues
Advanced configuration options

🚀 Deployment

For production deployment guides including Nginx, Apache, and cloud platforms:

📖 Deployment Guide → docs.horilla.com/technical/v2.0/doc/deployment/nginx-gunicorn

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

# Fork and clone your fork
git clone -b dev/v2.0 https://github.com/YOUR_USERNAME/horilla-hr.git
cd horilla-hr

# Add upstream remote
git remote add upstream https://github.com/horilla/horilla-hr.git

# Create feature branch
git checkout -b feature/your-feature-name

# Install development dependencies
pip install -r requirements.txt

# Submit pull request

Note: 2.0 is the repo default, so GitHub pre-selects it as your PR base. Before submitting, change the base branch to dev/v2.0 — that's where active development and reviews happen, not 2.0.

Code Standards

Follow PEP 8 for Python code
Use Black for code formatting
Write tests for new features
Update documentation for user-facing changes

🔒 Security

Security Features

🔐 Authentication & Authorization - Role-based access control
🛡️ Data Protection - Encrypted sensitive data storage
🔍 Audit Trails - Comprehensive activity logging
🚫 Input Validation - XSS and injection protection
🔒 Session Security - Secure session management

Reporting Security Issues

Please report security vulnerabilities via GitHub Private Vulnerability Reporting, not email. Do not create public GitHub issues for security vulnerabilities. See SECURITY.md for full details.

Security Best Practices

Always use HTTPS in production
Regularly update dependencies
Use strong passwords and enable 2FA
Monitor logs for suspicious activities

📞 Support

Community Support

📖 Documentation: docs.horilla.com
💬 GitHub Discussions: GitHub Discussions
🐛 Bug Reports: GitHub Issues
✨ Feature Requests: GitHub Issues

Professional Support

For enterprise support, custom development, and consulting services:

📧 Email: support@horilla.com
🌐 Website: www.horilla.com

📄 License

This project is licensed under the LGPL-2.1 License - see the LICENSE file for details.

Made with ❤️ by the Horilla Team

⭐ Star us on GitHub | 🐛 Report Bug | 💡 Request Feature

gustavoguanabara/html-css

Curso de HTML5 e CSS3

https://gustavoguanabara.github.io/html-css/

Curso de HTML5 e CSS3

Material público para o ensino básico de HTML5 e CSS3 para alunos iniciantes. Acesse o material em PDF, analise o código disponibilizado para cada exercício e veja-os funcionando em execução direta via repositório GitHub.

Direitos de uso

Você tem todo o direito de usar esse material para seu próprio aprendizado. Professores também podem ter acesso a todo o conteúdo e usá-los com seus alunos. Porém todos o que usarem esse material - seja para qual for a finalidade - deverão manter a referência ao material original, criado e disponibilizado pelo Prof. Gustavo Guanabara. Este conteúdo não poderá ser utilizado em nenhuma hipótese para ser replicada - integral ou parcialmente - por autores/ editoras/ instituições de ensino para criar livros ou apostilas, com finalidades de obter ganho financeiro com ele.