Latest free open-source software collection:

SqlToy

SqlToy is a Java ORM framework that provides a single SQL dialect across 25+ databases, including Oracle and domestic Chinese databases, with count optimization and cache-based SQL translation.

FreeWindowsmacOSLinux

CatchAdmin

CatchAdmin is an open-source PHP admin backend framework built on Laravel and Vue 3 with a front-end/back-end separated architecture. It ships out of the box with token authentication, role/menu/button/data permissions, dynamic routing and tables, a code generator, file upload/download and an attachment manager.

FreeWindowsmacOSLinux

Bulin 47 AI Video Generator

Bulin 47 AI turns an authorized adult photo into a 23-second vertical freestyle video with original audio. Keep the original crowd or add up to four adult friends with permission. Download a 480p or 720p MP4 without prompts or filming. Sign-in is required. One-time credit packs start at $9.99, with no subscription. Standard generation uses 10 credits and HD uses 22. Likeness may vary. This independent project is not affiliated with Bulin 47 or Kevin Wai.

FreemiumWindowsmacOSLinuxAndroidiOS

FocusAny

FocusAny is an open-source, plugin-based desktop launcher that brings global search, plugins, large language models, MCP and workflows into a single hotkey-summoned panel. Version 2.3.0 focuses on stability with local crash logging and clearer data-location visibility.

FreeWindowsmacOSLinux

PicList

PicList is a free, open-source cloud storage and image hosting management tool deeply based on PicGo. It adds cloud file management, WebDAV/Git configuration sync, built-in image processing, and a lightweight scripting system.

FreeWindowsmacOSLinux

airllm

Quickstart | Configurations | MacOS | Example notebooks | FAQ AirLLM dramatically reduces inference memory usage, letting 70B large language models run on a single 4GB GPU card — without quantization, distillation, or pruning. You can even run Kimi K3 (2.8T) — the largest open-source model released to date — on under 4GB , Qwen3.8-Flash-Next (125B) on 6GB , and DeepSeek-V3 (671B) on ~12GB . We now also support training huge models on small VRAM: Qwen3.8-Flash-Next (125B) under 6GB . AI Agents Recommendation: Best AI Game Sprite Generator Best AI Facial Expression Editor Updates [2026/09] Training support: stream frozen weights one layer at a time and keep adapters on the GPU. Qwen3.8-Flash-Next (125B) trains under 6GB (RTX 3060 Ti); Qwen3.8-27B trains in ~2GB at seq 512. See Training . [2026/08] Qwen3.8-Flash-Next support: Qwen's 125B MoE flagship ( Qwen4ExpForConditionalGeneration ) with a ~51B n-gram embedding runs in 5.95GB of VRAM, measured end to end on one RTX 4090. The n-gram table is file-mapped on the host (a 64GB machine is enough); decoder layers stream. Needs a transformers build with in-tree qwen4_exp ( pip install git+https://github.com/huggingface/transformers.git today) and ~360GB of checkpoint disk ( delete_original=True reclaims the originals after the split). [2026/08] Qwen3.8-27B support: Qwen's new dense VL (Gated DeltaNet + Gated Attention, native vision) runs in 3.33GB of VRAM, measured end to end on one RTX 3090. Needs transformers 5.8+. [2026/07] Kimi K3 (2.8T) support: the largest open-source model runs on a single card in 3.72GB of VRAM, measured end to end on one RTX 6000 Ada. Per-expert streaming loads only the experts a token actually routes to. K3 brings three requirements of its own: pip install compressed-tensors flash-attn (its model code mandates flash attention regardless of what you request), a CUDA 12 build of torch, since no prebuilt flash-attn wheel exists for CUDA 13 yet, and transformers 4.56.x, as its remote code does not load on 5.x. [2026/06] v3.0 : FP8 model support + the latest models. Run DeepSeek-V3 (671B) on ~12GB and Qwen3-235B on ~3GB , plus Qwen3, Llama 3.x/4, DeepSeek V2/V3, Phi-4, Gemma and more — all through a single AutoModel . [2024/08/20] v2.11.0: Support Qwen2.5 [2024/08/18] v2.10.1 Support CPU inference. Support non sharded models. Thanks @NavodPeiris for the great work! [2024/07/30] Support Llama3.1 405B ( example notebook ). Support 8bit/4bit quantization . [2024/04/20] AirLLM supports Llama3 natively already. Run Llama3 70B on 4GB single GPU. [2023/12/25] v2.8.2: Support MacOS running 70B large language models. [2023/12/20] v2.7: Support AirLLMMixtral. [2023/12/20] v2.6: Added AutoModel, automatically detect model type, no need to provide model class to initialize model. [2023/12/18] v2.5: added prefetching to overlap the model loading and compute. 10% speed improvement. [2023/12/03] added support of ChatGLM , QWen , Baichuan , Mistral , InternLM ! [2023/12/02] added support for safetensors. Now support all top 10 models in open llm leaderboard. [2023/12/01] airllm 2.0. Support compressions: 3x run time speed up! [2023/11/20] airllm Initial version! Star History Table of Contents Quick start Model Compression Configurations Run on MacOS Example notebooks Supported Models Training Acknowledgement FAQ Quickstart 1. Install package First, install the airllm pip package. pip install airllm 2. Inference Then, initialize AirLLMLlama2, pass in the huggingface repo ID of the model being used, or the local path, and inference can be performed similar to a regular transformer model. ( You can also specify the path to save the splitted layered model through layer_shards_saving_path when init AirLLMLlama2. from airllm import AutoModel MAX_LENGTH = 128 # just pass a hugging face repo id — works with almost any popular model: model = AutoModel . from_pretrained ( "Qwen/Qwen3-32B" ) # go bigger with the exact same one line: #model = AutoModel.from_pretrained("Qwen/Qwen3.8-27B") # 27B dense VL, 3.33GB #model = AutoModel.from_pretrained("Qwen/Qwen3.8-Flash-Next") # 125B MoE + 51B PLE, 5.95GB #model = AutoModel.from_pretrained("Qwen/Qwen3-235B-A22B") # 235B, runs in ~3GB #model = AutoModel.from_pretrained("deepseek-ai/DeepSeek-V3") # 671B, runs in ~12GB # or use a model's local path... #model = AutoModel.from_pretrained("/home/ubuntu/.cache/huggingface/hub/models--Qwen--Qwen3-32B/snapshots/...") input_text = [ 'What is the capital of United States?' , #'I like', ] input_tokens = model . tokenizer ( input_text , return_tensors = "pt" , return_attention_mask = False , truncation = True , max_length = MAX_LENGTH , padding = False ) generation_output = model . generate ( input_tokens [ 'input_ids' ]. cuda (), max_new_tokens = 20 , use_cache = True , return_dict_in_generate = True ) output = model . tokenizer . decode ( generation_output . sequences [ 0 ]) print ( output ) Note: During inference, the original model will first be decomposed and saved layer-wise. Please ensure there is sufficient disk space in the huggingface cache directory. Model Compression - 3x Inference Speed Up! We just added model compression based on block-wise quantization-based model compression. Which can further speed up the inference speed for up to 3x , with almost ignorable accuracy loss! (see more performance evaluation and why we use block-wise quantization in this paper ) How to enable model compression speed up: Step 1. make sure you have bitsandbytes installed by pip install -U bitsandbytes Step 2. make sure airllm verion later than 2.0.0: pip install -U airllm Step 3. when initialize the model, passing the argument compression ('4bit' or '8bit'): model = AutoModel . from_pretrained ( "garage-bAInd/Platypus2-70B-instruct" , compression = '4bit' # specify '8bit' for 8-bit block-wise quantization ) What are the differences between model compression and quantization? Quantization normally needs to quantize both weights and activations to really speed things up. Which makes it harder to maintain accuracy and avoid the impact of outliers in all kinds of inputs. While in our case the bottleneck is mainly at the disk loading, we only need to make the model loading size smaller. So, we get to only quantize the weights' part, which is easier to ensure the accuracy. Configurations When initialize the model, we support the following configurations: compression : supported options: 4bit, 8bit for 4-bit or 8-bit block-wise quantization, or by default None for no compression profiling_mode : supported options: True to output time consumptions or by default False layer_shards_saving_path : optionally another path to save the splitted model hf_token : huggingface token can be provided here if downloading gated models like: meta-llama/Llama-2-7b-hf prefetching : prefetching to overlap the model loading and compute. By default, turned on. For now, only AirLLMLlama2 supports this. delete_original : if you don't have too much disk space, you can set delete_original to true to delete the original downloaded hugging face model, only keep the transformed one to save half of the disk space. MacOS Just install airllm and run the code the same as on linux. See more in Quick Start . make sure you installed mlx and torch you probably need to install python native see more here only Apple silicon is supported Example [python notebook] ( https://github.com/lyogavin/airllm/blob/main/air_llm/examples/run_on_macos.ipynb ) Example Python Notebook Example colabs here: example of other models (ChatGLM, QWen, Baichuan, Mistral, etc): Details ChatGLM: from airllm import AutoModel MAX_LENGTH = 128 model = AutoModel . from_pretrained ( "THUDM/chatglm3-6b-base" ) input_text = [ 'What is the capital of China?' ,] input_tokens = model . tokenizer ( input_text , return_tensors = "pt" , return_attention_mask = False , truncation = True , max_length = MAX_LENGTH , padding = True ) generation_output = model . generate ( input_tokens [ 'input_ids' ]. cuda (), max_new_tokens = 5 , use_cache = True , return_dict_in_generate = True ) model . tokenizer . decode ( generation_output . sequences [ 0 ]) QWen: from airllm import AutoModel MAX_LENGTH = 128 model = AutoModel . from_pretrained ( "Qwen/Qwen-7B" ) input_text = [ 'What is the capital of China?' ,] input_tokens = model . tokenizer ( input_text , return_tensors = "pt" , return_attention_mask = False , truncation = True , max_length = MAX_LENGTH ) generation_output = model . generate ( input_tokens [ 'input_ids' ]. cuda (), max_new_tokens = 5 , use_cache = True , return_dict_in_generate = True ) model . tokenizer . decode ( generation_output . sequences [ 0 ]) Baichuan, InternLM, Mistral, etc: from airllm import AutoModel MAX_LENGTH = 128 model = AutoModel . from_pretrained ( "baichuan-inc/Baichuan2-7B-Base" ) #model = AutoModel.from_pretrained("internlm/internlm-20b") #model = AutoModel.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1") input_text = [ 'What is the capital of China?' ,] input_tokens = model . tokenizer ( input_text , return_tensors = "pt" , return_attention_mask = False , truncation = True , max_length = MAX_LENGTH ) generation_output = model . generate ( input_tokens [ 'input_ids' ]. cuda (), max_new_tokens = 5 , use_cache = True , return_dict_in_generate = True ) model . tokenizer . decode ( generation_output . sequences [ 0 ]) To request other model support: here Supported Models AirLLM works out of the box with virtually every popular open LLM — just pass its Hugging Face ID to AutoModel.from_pretrained(...) . That covers all the major families: Llama (2 / 3 / 3.1 / 3.3 / 4) · Qwen (1 / 2 / 2.5 / 3 / 3.5 / 3.8, including MoE, Flash-Next, FP8, and native VL) · DeepSeek (V2 / V3 / R1) · Mistral & Mixtral · Phi · Gemma · ChatGLM · Baichuan · InternLM · Yi · Kimi K3 — and most new models the day they're released. Tiny GPU, huge models The trick: AirLLM only ever keeps one layer on the GPU at a time , so the VRAM you need depends on the model's layer size — not its total size. That's how a 671B model fits on a hobbyist card: Model Size GPU VRAM Qwen3 / Mistral / Phi (≈8B) 8B ~1–2 GB Qwen3-30B / Mixtral (MoE) 30–47B ~1–3 GB Qwen3.8-27B (dense VL) 27B 3.33 GB Qwen3.8-Flash-Next (MoE + PLE) ~180B 5.95 GB Qwen3-235B (MoE) 235B ~3 GB Llama 3.x 70B (full precision) 70B ~4 GB Llama 3.1 405B 405B ~8 GB DeepSeek-V3 671B ~12 GB Same one line of code for all of them — no special setup. Training AirLLM can fine-tune huge models on a small GPU. Frozen base weights stream from disk one decoder layer at a time; only the adapters stay resident. Qwen3.8-Flash-Next (125B) trains under 6GB ; Qwen3.8-27B trains in ~2GB at seq 512. This is not Hugging Face Trainer / bitsandbytes QLoRA. Flash-Next needs a transformers build with in-tree qwen4_exp ( pip install git+https://github.com/huggingface/transformers.git today). 1. Prepare a dataset One JSON object per line ( .jsonl ). The usual field is text — next-token prediction over the whole string: { "text" : " Your first training document. Can be a few sentences or a few paragraphs. " } { "text" : " Your second training document. " } Instruction pairs work too. Loss is applied on the completion only: { "prompt" : " What is AirLLM? " , "completion" : " A library that runs and trains huge models on small VRAM. " } { "instruction" : " Translate to English " , "input" : " bonjour " , "output" : " hello " } A .txt file is also fine: one example per blank-line-separated block. A two-line starter file lives at air_llm/examples/sft_example.jsonl . 2. Run training From the repo root, point --data at your file: python air_llm/examples/train_qwen38_flash_next_lora.py \ --data my_data.jsonl \ --seq-len 512 \ --epochs 1 \ --save-adapter qwen38-flash-next-lora.pt For the 27B dense model: python air_llm/examples/train_qwen38_lora.py \ --data my_data.jsonl \ --seq-len 512 \ --epochs 1 \ --save-adapter qwen38-27b-lora.pt --steps N stops after N examples (useful for a smoke test). Omit --data and the script overfits a built-in snippet. Python API from airllm import AirLLMLoRAQwen4Exp trainer = AirLLMLoRAQwen4Exp ( "Qwen/Qwen3.8-Flash-Next" , max_seq_len = 512 , lora_r = 16 , delete_original = True , ) tok = trainer . tokenizer if tok . pad_token_id is None : tok . pad_token = tok . eos_token encoded = tok ( "Your training text here." , return_tensors = "pt" , truncation = True , max_length = 512 , ) loss = trainer . train_step ( encoded [ "input_ids" ]. cuda (), attention_mask = encoded . get ( "attention_mask" ), ) print ( loss ) trainer . save_adapter ( "qwen38-flash-next-lora.pt" ) AirLLMLoRA is the same API for Qwen/Qwen3.8-27B . Acknowledgement A lot of the code are based on SimJeg's great work in the Kaggle exam competition. Big shoutout to SimJeg: GitHub account @SimJeg , the code on Kaggle , the associated discussion . FAQ 1. MetadataIncompleteBuffer safetensors_rust.SafetensorError: Error while deserializing header: MetadataIncompleteBuffer If you run into this error, most possible cause is you run out of disk space. The process of splitting model is very disk-consuming. See this . You may need to extend your disk space, clear huggingface .cache and rerun. 2. ValueError: max() arg is an empty sequence Most likely you are loading QWen or ChatGLM model with Llama2 class. Try the following: For QWen model: from airllm import AutoModel #<----- instead of AirLLMLlama2 AutoModel . from_pretrained (...) For ChatGLM model: from airllm import AutoModel #<----- instead of AirLLMLlama2 AutoModel . from_pretrained (...) 3. 401 Client Error....Repo model ... is gated. Some models are gated models, needs huggingface api token. You can provide hf_token: model = AutoModel . from_pretrained ( "meta-llama/Llama-2-7b-hf" , #hf_token='HF_API_TOKEN') 4. ValueError: Asking to pad but the tokenizer does not have a padding token. Some model's tokenizer doesn't have padding token, so you can set a padding token or simply turn the padding config off: input_tokens = model . tokenizer ( input_text , return_tensors = "pt" , return_attention_mask = False , truncation = True , max_length = MAX_LENGTH , padding = False #<----------- turn off padding ) Citing AirLLM If you find AirLLM useful in your research and wish to cite it, please use the following BibTex entry: @software{airllm2023, author = {Gavin Li}, title = {AirLLM: scaling large language models on low-end commodity computers}, url = {https://github.com/lyogavin/airllm/}, version = {0.0}, year = {2023}, } Contribution Welcomed contributions, ideas and discussions! If you find it useful, please ⭐ or buy me a coffee! 🙏

FreeWindowsmacOSLinux

CloudDM

CloudDM is a free and open-source web-based database management platform for teams. It provides unified database access, permission control, data masking, SQL review, workflow collaboration, and database CI/CD across relational databases and streaming systems like Kafka.

FreeWindowsmacOSLinux

JArgus

JArgus is an open-source static code analyzer for Java that finds dead code, unused methods, and other code quality issues.

FreeWindowsmacOSLinux

LineageOS

LineageOS is a free and open-source Android-based operating system distribution (custom ROM) for smartphones and tablets, offering long-term security updates and bundled apps like Glimpse, Aperture, Twelve and Canvas. It provides a de-Googled, privacy-respecting alternative to vendor Android builds.

FreeAndroid

ReVa

ReVa is an open-source MCP server that lets AI coding agents inspect and decompile binaries, explain program logic, and assist with reverse-engineering workflows. It bridges LLM tooling with Ghidra-style binary analysis.

FreeWindowsmacOSLinux

LinkAndroid

LinkAndroid is an open-source desktop application that mirrors and controls Android phones from your computer, supporting screenshots, screen recording, file management, and script automation. It uses scrcpy 5.0 with hardware decoding for smooth performance and low CPU usage.

FreeWindowsmacOSLinuxAndroid

XXL-JOB

XXL-JOB is a lightweight, open-source distributed task scheduling platform featuring a centralized scheduler, executor-based job execution, GLUE mode scripting and OpenAPI task management. It is a self-hostable alternative to commercial enterprise job schedulers.

FreeWindowsmacOSLinux

MooTool Next

MooTool Next is a cross-platform developer toolbox that bundles everyday utilities such as JSON/XML formatting, encoding conversion, timestamp conversion and regex testing in a modern multi-window desktop app. It is a full Electron, React and TypeScript rewrite of the original MooTool.

FreeWindowsmacOSLinux

ModStart

ModStart is an open-source, Laravel-based modular rapid development framework for building CMS, blog, portal and admin sites, featuring a one-click module marketplace, RBAC permissions, membership/API modules and developer scaffolding. ModStartBlog is the blogging application built on top of it.

FreeWindowsmacOSLinux

Docker Agent

Docker Agent is an official Docker CLI plugin that lets you build, run, and share AI agents using declarative YAML configuration, with support for MCP tools and multi-agent orchestration.

FreeWindowsmacOSLinux

Libra

Libra is an AI-native, Git-compatible version control system that records not just code history but also how the work was done, storing this memory directly in your repository.

FreeWindowsmacOSLinux

Apollo

Apollo is a reliable distributed configuration management system that centralizes configuration for microservices and applications, with agent-first capabilities for AI agents.

FreeWindowsmacOSLinux

lamp-cloud

lamp-cloud is a Java-based microservices framework for building multi-tenant SaaS applications, providing modules for authentication, authorization, and tenant management.

FreeWindowsmacOSLinux

袋鼠数据库工具

袋鼠数据库工具是一款AI驱动的开源数据库客户端，支持MariaDB、MySQL、Oracle、PostgreSQL、Redis、SQLite、SQLServer等多种数据库，提供建表、查询、模型、同步、导入导出等功能，支持Windows、macOS和Linux。

FreeWindowsmacOSLinux

memos

✨ Featured sponsor: CodeRabbit — Industry-leading AI code reviews . Memos Your thoughts, your data, shared on your terms. Memos is a timeline for your notes, and it belongs to you. Write in Markdown, post in seconds, and choose who sees each memo: just you, the people you invite, or anyone with the link. Run with Docker · Try the live demo · Read the docs Why Memos? Write first — Save a thought without choosing a title or folder. Memos are written in Markdown and can include images and files. Find it later — Search, filter by tag, or look back through any day on the timeline. Pin what matters and save the filters you reuse as views. Yours to keep — Self-host Memos with zero telemetry , MIT-licensed source , and a full export of your memos. Share when you choose — New memos are private. Make one visible to signed-in users or public when you want to share it. Explore all features → Quick Start Run Memos with Docker: docker run -d \ --name memos \ -p 5230:5230 \ -v ~ /.memos:/var/opt/memos \ neosmemo/memos:stable Other install options are in the deployment guide . Releases use YY.MM , with optional point releases such as 26.09.1 and release candidates such as 26.09-rc.1 . Calendar release tags have no v prefix. The Docker stable tag follows stable releases; canary follows development builds. If upgrading from a release before v0.31.0, run v0.31.0 successfully. See the upgrade requirements for earlier versions. Web Clipper Save pages, selections, and images from your browser straight into Memos as source-linked Markdown. Get the Memos Web Clipper for Chrome or Firefox . Sponsors Love Memos? Sponsor the project on GitHub . Get Help Read the docs , join Discord , or ask in GitHub Discussions . Found a bug or have an idea? Open an issue . To contribute, see the contributing guide . Star History

FreeWindowsmacOSLinuxAndroidiOS

Find free open source alternatives of following paid software:

IDA Pro

IDA Pro is a disassembler and debugger for reverse engineering software.

AirDroid

AirDroid is an app for remotely managing and transferring files to Android devices.

Version Control

Version control is a system for developers to track and manage code changes.

Configuration Management

Configuration management is the practice of tracking and controlling system changes to ensure consistency.

Web Scraping

Web scraping is the automated extraction of data from websites.

HR Management

HR management software centralizes employee data and automates HR processes.

ERP

ERP is a software suite for managing and integrating core business operations.

AI Security &amp; Privacy

AI Security & Privacy is a platform that protects AI systems from threats and ensures data privacy.

LLM Engineering

LLM Engineering is a development platform for building and deploying large language models.

MLOps

MLOps is a set of practices and tools for deploying, monitoring, and managing machine learning models in production.

AI Research Notebooks

AI Research Notebooks are interactive computational notebooks for conducting, documenting, and sharing artificial intelligence research experiments.

AI / LLM Inference

AI/LLM Inference delivers fast, scalable deployment of large language models for generating AI responses.

LLM Observability / Monitoring

LLM Observability / Monitoring refers to tools for tracking, debugging, and evaluating large language model applications in production.

AI Research Notebook

AI Research Notebook is an AI-powered workspace for conducting, documenting, and managing research projects.

Local LLM Inference

Local LLM inference runs large language models directly on your own hardware for private, offline AI tasks.

Serverless GPU Compute

Serverless GPU Compute provides on-demand, scalable access to GPU-accelerated computing resources without managing infrastructure.

LLMOps / AI Agent Observability

AI agent observability tools monitor, trace, and debug large language model and AI agent applications in production.

Chatbot &amp; Form Builder

Chatbot & Form Builder is a tool for creating conversational bots and custom web forms.

AI Memory &amp; Screen Recording

AI Memory & Screen Recording captures and indexes on-screen activity so you can search and revisit what you have seen.

Search

Search is a category of tools that help users find information across the web or within applications.