DEV Community: classccai

aios

classccai — Fri, 24 Apr 2026 07:13:34 +0000

AIOS: AI Agent Operating System

📰 News

[2025-07-08] 🎉 The foundational paper AIOS: LLM Agent Operating System has been accepted by the Conference on Language Modeling (COLM 2025). Congratulations to the team!
[2025-07-02] 🎉 AIOS has been selected as the finalist for AgentX – LLM Agents MOOC Competition, hosted by Berkeley RDI in conjunction with the Advanced LLM Agents MOOC. Congratulations to the team!
[2025-05-24] 📋 Check out our paper on computer-use agent: LiteCUA: Computer as MCP Server for Computer-Use Agent on AIOS and the corresponding codebase.
[2025-03-13] 📋 Paper Cerebrum (AIOS SDK): A Platform for Agent Development, Deployment, Distribution, and Discovery has been accepted by NAACL 2025! Features has been integrated into Cerebrum.
[2025-03-12] 🔥 A major refactor of the codebase packed with powerful new features have been integrated into the main repo. Please check out the AIOS v0.2.2 release.
[2025-03-10] 📋 Check out our paper on agentic memory A-MEM: Agentic Memory for LLM Agents and the corresponding codebase.
[2025-02-07] 📋 Our paper From Commands to Prompts: LLM-based Semantic File System for AIOS has been accepted by ICLR2025! The features of this paper has been integrated into AIOS as the Terminal UI.
[2025-01-27] 🔥 Deepseek-r1 (1.5b, 7b, 8b, 14b, 32b, 70b, 671b) has already been supported in AIOS, both open-sourced versions and deepseek apis (deepseek-chat and deepseek-reasoner) are available.
[2024-11-30] 🔥 AIOS v0.2: Disentangled AIOS Kernel (this AIOS repository) and AIOS SDK (The Cerebrum repository), Remote Kernel for agent users.
[2024-09-01] 🔥 AIOS supports multiple agent creation frameworks (e.g., ReAct, Reflexion, OpenAGI, AutoGen, Open Interpreter, MetaGPT). Agents created by these frameworks can onboard AIOS. Onboarding guidelines can be found at the Doc.
[2024-07-10] 📖 AIOS documentation is up, which can be found at Website.
[2024-06-20] 🔥 Function calling for open-sourced LLMs (native huggingface, vLLM, ollama) is supported.
[2024-05-20] 🚀 More agents with ChatGPT-based tool calling are added (i.e., MathAgent, RecAgent, TravelAgent, AcademicAgent and CreationAgent), their profiles and workflows can be found in OpenAGI.
[2024-05-13] 🛠️ Local models (diffusion models) as tools from HuggingFace are integrated.
[2024-05-01] 🛠️ The agent creation in AIOS is refactored, which can be found in our OpenAGI package.
[2024-04-05] 🛠️ AIOS currently supports external tool callings (google search, wolframalpha, rapid API, etc).
[2024-04-02] 🤝 AIOS Discord Community is up. Welcome to join the community for discussions, brainstorming, development, or just random chats! For how to contribute to AIOS, please see CONTRIBUTE.
[2024-03-25] ✈️ Our paper AIOS: LLM Agent Operating System is released!
[2023-12-06] 📋 After several months of working, our perspective paper LLM as OS, Agents as Apps: Envisioning AIOS, Agents and the AIOS-Agent Ecosystem is officially released.

Different deployment modes of AIOS

Here are some key notations that are required to know before introducing the different modes of AIOS.

AHM (Agent Hub Machine): Central server that hosts the agent marketplace/repository where users can publish, download, and share agents. Acts as the distribution center for all agent-related resources.
AUM (Agent UI Machine): Client machine that provides user interface for interacting with agents. Can be any device from mobile phones to desktops that supports agent visualization and control.
ADM (Agent Development Machine): Development environment where agent developers write, debug and test their agents. Requires proper development tools and libraries.
ARM (Agent Running Machine): Execution environment where agents actually run and perform tasks. Needs adequate computational resources for agent operations.

The following parts introduce different modes of deploying AIOS. Currently, AIOS already supports Mode 1 and Mode 2, other modes with new features are still ongoing.

Mode 1 (Local Kernel Mode)

Features:
- For agent users: They can download agents from agent hub from Machine B and run agents on Machine A.
- For agent developers: They can develop and test agents in Machine A and can upload agents to agent hub on Machine B.

Mode 2 (Remote Kernel Mode)

Features:
- Remote use of agents: Agent users / developers can use agents on Machine B, which is different from the development and running machine (Machine A).
- Benefit users who would like to use agents on resource-restricted machine (e.g., mobile device or edge device)

Mode 2.5 (Remote Kernel Dev Mode)

Features:
- Remote development of agents: Agent developers can develop their agents on Machine B while running and testing their agents in Machine A. Benefit developers who would like to develop agents on resource-restricted machine (e.g., mobile device or edge device)
Critical technique:
- Packaging and agent transmission on different machines for distributed agent development and testing

Mode 3 (Personal Remote Kernel Mode)

Ongoing Features:
- Each user/developer can have their personal AIOS with long-term persistent data as long as they have registered account in the AIOS ecosystem
- Their personal data can be synced to different machines with the same account
Critical techniques:
- User account registration and verification mechanism
- Persistent personal data storage for each user's AIOS
- Synchronization for different AIOS instances on different devices within the same account
- Data privacy mechanism

Mode 4 (Personal Remote Virtual Kernel Mode)

Ongoing Features:
- Different user/developer's personal AIOS kernels can co-exist in the same physical machine through virtualization
Critical techniques:
- Virtualization of different AIOS kernel instances in the same machine
- Scheduling and resource allocation mechanism for different virtual machines located in the same machine

✈️ Getting Started

Please see our ongoing documentation for more information.

Installation

Requirements

Python

Supported versions: Python 3.10 - 3.11

Installation from source

Step 1: Install AIOS Kernel

Git clone AIOS kernel

git clone https://github.com/agiresearch/AIOS.git

Create venv environment

python3.x -m venv venv # Only support for Python 3.10 and 3.11
source venv/bin/activate

or create conda environment

conda create -n venv python=3.x  # Only support for Python 3.10 and 3.11
conda activate venv

[!TIP]
We strongly recommend using uv for faster and more reliable package installation.
To install uv:

bash pip install uv

For GPU environments:

uv pip install -r requirements-cuda.txt

For CPU-only environments:

uv pip install -r requirements.txt

Alternatively, if you prefer using pip:

For GPU environments:

pip install -r requirements-cuda.txt

For CPU-only environments:

pip install -r requirements.txt

Step 2: Install AIOS SDK (Cerebrum)

Clone the Cerebrum repository:

   git clone https://github.com/agiresearch/Cerebrum.git

Install using uv (recommended):

   cd Cerebrum && uv pip install -e .

Or using pip:

   cd Cerebrum && pip install -e .

Step 3: Install Virtualized Environment (Optional)

To use the mcp for computer-use agent, we strongly recommend you install a virtualized environment equipped with GUI. Instructions can be found in here.

Note: The machine where the AIOS kernel (AIOS) is installed must also have the AIOS SDK (Cerebrum) installed. Installing AIOS kernel will install the AIOS SDK automatically by default. If you are using the Local Kernel mode, i.e., you are running AIOS and agents on the same machine, then simply install both AIOS and Cerebrum on that machine. If you are using Remote Kernel mode, i.e., running AIOS on Machine 1 and running agents on Machine 2 and the agents remotely interact with the kernel, then you need to install both AIOS kernel and AIOS SDK on Machine 1, and install the AIOS SDK alone on Machine 2. Please follow the guidelines at Cerebrum regarding how to install the SDK.

Quickstart

Before launching AIOS, it is required to set up configurations. AIOS provides two ways of setting up configurations, one is to set up by directly modifying the configuration file, another is to set up interactively.

Set up configuration file directly (Recommended)

You need API keys for services like OpenAI, Anthropic, Groq and HuggingFace. The simplest way to configure them is to edit the aios/config/config.yaml.

[!TIP]
It is important to mention that, we strongly recommend using the aios/config/config.yaml file to set up your API keys. This method is straightforward and helps avoid potential sychronization issues with environment variables.

A simple example to set up your API keys in aios/config/config.yaml is shown below:

api_keys:
  openai: "your-openai-key"    
  gemini: "your-gemini-key"    
  groq: "your-groq-key"      
  anthropic: "your-anthropic-key" 
  huggingface:
    auth_token: "your-huggingface-token-for-authorized-models"  
    cache_dir: "your-cache-dir-for-saving-models"
  novita: "your-novita-api-key"

To obtain these API keys:

Deepseek API: Visit https://api-docs.deepseek.com/
OpenAI API: Visit https://platform.openai.com/api-keys
Google Gemini API: Visit https://makersuite.google.com/app/apikey
Groq API: Visit https://console.groq.com/keys
HuggingFace Token: Visit https://huggingface.co/settings/tokens
Anthropic API: Visit https://console.anthropic.com/keys
Novita AI API: Visit https://novita.ai/api-keys

Configure LLM Models

You can configure which LLM models to use in the same aios/config/config.yaml file. Here's an example configuration:

llms:
  models:
    # Ollama Models
    - name: "qwen2.5:7b"
      backend: "ollama"
      hostname: "http://localhost:11434"  # Make sure to run ollama server

    # vLLM Models
    - name: "meta-llama/Llama-3.1-8B-Instruct"
      backend: "vllm"
      hostname: "http://localhost:8091/v1"  # Make sure to run vllm server

Using Ollama Models:

First, download ollama from https://ollama.com/
Start the ollama server in a separate terminal:

ollama serve

Pull your desired models from https://ollama.com/library:

ollama pull qwen2.5:7b  # example model

[!TIP]
Ollama supports both CPU-only and GPU environments. For more details about ollama usage, visit ollama documentation

Using vLLM Models:

Install vLLM following their installation guide
Start the vLLM server in a separate terminal:

vllm serve meta-llama/Llama-3.1-8B-Instruct --port 8091

[!NOTE]
vLLM currently only supports Linux and GPU-enabled environments. If you don't have a compatible environment, please choose other backend options.
To enable the tool calling feature of vllm, refer to https://docs.vllm.ai/en/latest/features/tool_calling.html

Using HuggingFace Models:
You can configure HuggingFace models with specific GPU memory allocation:

- name: "meta-llama/Llama-3.1-8B-Instruct"
  backend: "huggingface"
  max_gpu_memory: {0: "24GB", 1: "24GB"}  # GPU memory allocation
  eval_device: "cuda:0"  # Device for model evaluation

Set up interactively

Alternatively, you can set up aios configurations interactively by using the following command.

aios env list: Show current environment variables, or show available API keys if no variables are set
aios env set: Show current environment variables, or show available API keys if no variables are set
aios refresh: Refresh AIOS configuration. Reloads the configuration from aios/config/config.yaml. Reinitializes all components without restarting the server. The server must be running.

When no environment variables are set, the following API keys will be shown:

DEEPSEEK_API_KEY: Deepseek API key for accessing Deepseek services
OPENAI_API_KEY: OpenAI API key for accessing OpenAI services
GEMINI_API_KEY: Google Gemini API key for accessing Google's Gemini services
GROQ_API_KEY: Groq API key for accessing Groq services
HF_AUTH_TOKEN: HuggingFace authentication token for accessing models
HF_HOME: Optional path to store HuggingFace models
NOVITA_API_KEY: Novita AI API key for accessing Novita AI services

Launch AIOS

After you setup your keys or environment parameters, then you can follow the instructions below to start.

Run:

bash runtime/launch_kernel.sh

Or if you need to explicity set the Python version by running python3.10, python3.11, python3, etc. run the command below:

python3.x -m uvicorn runtime.launch:app --host 0.0.0.0 --port 8000 # replace the port with your own port

You also need to set up the host and port in the configuration of Cerebrum (AIOS SDK) to make sure it is consistent with the configurations of AIOS.

You can also force the kernel to run in the background with:

python3.x -m uvicorn runtime.launch:app --host 0.0.0.0 > uvicorn.log 2>&1 &

And you can run it even after the shell closes by typing nohup before the entire command.

Command to launch the kernel in the background so it continues running even after the active shell is closed, while also logging information to the specified log file (recommended):

nohup python3 -m uvicorn runtime.launch:app --host 0.0.0.0 --port 8000 > uvicorn.log 2>&1 &

Interact with AIOS terminal

To interact with the AIOS terminal (LLM-based semantic file system), you can run the following command to start the AIOS terminal.

python scripts/run_terminal.py

Then you can start interacting with the AIOS terminal by typing natural language commands.

If you successfully start the AIOS terminal, it will be shown as below:

Detailed instructions of how to use the AIOS terminal can be found at here

[!WARNING]
The rollback feature of the AIOS terminal requires the connection to the redis server. Make sure you have the redis server running if you would like to use the rollback feature.

Run computer-use Agent

Make sure you have installed a virtualized environment with GUI, then you can refer to Cerebrum for how to run the computer-use agent.

Supported Agent Frameworks

Supported LLM Cores

Provider 🏢	Model Name 🤖	Open Source 🔓	Model String ⌨️	Backend ⚙️	Required API Key
Anthropic	All Models	❌	model-name	anthropic	ANTHROPIC_API_KEY
OpenAI	All Models	✅	model-name	openai	OPENAI_API_KEY
Deepseek	All Models	✅	model-name	deepseek	DEEPSEEK_API_KEY
Google	All Models	❌	model-name	gemini	GEMINI_API_KEY
Groq	All Models	✅	model-name	groq	GROQ_API_KEY
HuggingFace	All Models	✅	model-name	huggingface	HF_HOME
ollama	All Models	✅	model-name	ollama	-
vLLM	All Models	✅	model-name	vllm	-
Novita	All Models	✅	model-name	novita	NOVITA_API_KEY

🔧 Experimental Rust Rewrite (aios-rs)

An early experimental Rust scaffold lives in aios-rs/ providing trait definitions and minimal placeholder implementations (context, memory, storage, tool, scheduler, llm). This is NOT feature-parity yet; it's a foundation for incremental porting and performance-focused components.

Try It

cd aios-rs
cargo build
cargo test

Example (Echo LLM + Noop Scheduler)

use aios_rs::prelude::*;

fn main() -> anyhow::Result<()> {
  let llm = std::sync::Arc::new(EchoLLM);
  let memory = std::sync::Arc::new(std::sync::Mutex::new(InMemoryMemoryManager::new()));
  let storage = std::sync::Arc::new(FsStorageManager::new("/tmp/aios_store"));
  let tool = std::sync::Arc::new(NoopToolManager);
  let mut scheduler = NoopScheduler::new(llm, memory, storage, tool);
  scheduler.start()?;
  scheduler.stop()?;
  Ok(())
}

Reference

@article{mei2025aios,
  title={AIOS: LLM Agent Operating System},
  author={Mei, Kai and Zhu, Xi and Xu, Wujiang and Hua, Wenyue and Jin, Mingyu and Li, Zelong and Xu, Shuyuan and Ye, Ruosong and Ge, Yingqiang and Zhang, Yongfeng}
  journal={In Proceedings of the 2nd Conference on Language Modeling (COLM 2025)},
  year={2025}
}
@article{mei2025litecua,
  title={LiteCUA: Computer as MCP Server for Computer-Use Agent on AIOS},
  author={Mei, Kai and Zhu, Xi and Gao, Hang and Lin, Shuhang and Zhang, Yongfeng},
  journal={arXiv preprint arXiv:2505.18829},
  year={2025}
}
@article{xu2025mem,
  title={A-Mem: Agentic Memory for LLM Agents},
  author={Xu, Wujiang and Liang, Zujie and Mei, Kai and Gao, Hang and Tan, Juntao and Zhang, Yongfeng},
  journal={arXiv:2502.12110},
  year={2025}
}
@inproceedings{rama2025cerebrum,
  title={Cerebrum (AIOS SDK): A Platform for Agent Development, Deployment, Distribution, and Discovery}, 
  author={Balaji Rama and Kai Mei and Yongfeng Zhang},
  booktitle={2025 Annual Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics},
  year={2025}
}
@inproceedings{shi2025from,
  title={From Commands to Prompts: {LLM}-based Semantic File System for AIOS},
  author={Zeru Shi and Kai Mei and Mingyu Jin and Yongye Su and Chaoji Zuo and Wenyue Hua and Wujiang Xu and Yujie Ren and Zirui Liu and Mengnan Du and Dong Deng and Yongfeng Zhang},
  booktitle={The Thirteenth International Conference on Learning Representations},
  year={2025},
  url={https://openreview.net/forum?id=2G021ZqUEZ}
}
@article{ge2023llm,
  title={LLM as OS, Agents as Apps: Envisioning AIOS, Agents and the AIOS-Agent Ecosystem},
  author={Ge, Yingqiang and Ren, Yujie and Hua, Wenyue and Xu, Shuyuan and Tan, Juntao and Zhang, Yongfeng},
  journal={arXiv:2312.03815},
  year={2023}
}

🚀 Contributions

For how to contribute, see CONTRIBUTE. If you would like to contribute to the codebase, issues or pull requests are always welcome!

🌍 AIOS Contributors

Acknowledgement

We learned the design and reused code from the following projects: LiteLLM, OSWorld.

🤝 Discord Channel

If you would like to join the community, ask questions, chat with fellows, learn about or propose new features, and participate in future developments, join our Discord Community!

antimicro

classccai — Fri, 24 Apr 2026 07:09:39 +0000

AntiMicroX

Description
License
Installation
Wiki
Command Line
D-Bus
Testing Under Linux
AntiMicroX Profiles
Support

❗Looking for a new maintainer❗

Due to lack of time and shifting focus of its developer AntiMicroX is looking for a new maintainer willing to continue development.

For now, this app will have only limited support and will not get any new features (unless coded by external contributors).

Link to discussion

Description

AntiMicroX is a graphical program used to map gamepad keys to keyboard, mouse, scripts and macros. You can use this program to control any desktop application with a gamepad on Linux🐧 and Windows 🪟.

It can be also used for generating SDL2 configuration (useful for mapping atypical gamepads to generic ones like xbox360).

We support X.org and Wayland.

Features:

Mapping of gamepads/joystick buttons to:
- keyboard buttons
- mouse buttons and moves
- scripts and executables
- macros consisting of elements mentioned above
Assigning multiple switchable sets of mappings to gamepad.
Auto profiles - assign profile to active application window (not in Wayland note).

This program is currently supported under various Linux
distributions.

This application is continuation of project called AntiMicro, which was later abandoned and revived by juliagoda.

Legacy repositories:

First AntiMicroX repository: https://github.com/juliagoda/antimicroX
Second, maintained by organization: https://github.com/AntiMicro/antimicro
First, original AntiMicro repository: https://github.com/Ryochan7/antimicro

Screenshots:

Disclaimer: Theme may depend on your system configuration.

License

This program is licensed under the GPL v.3. Please read the LICENSE text document
included with the source code if you would like to read the terms of the license.
The license can also be found online at
http://www.gnu.org/licenses/gpl.txt

Installation

Windows

Just download antimicrox-X.X.X-AMD64.exe from Release site and install it.

Flatpak

The flatpak version is distributed on Flathub, and runs on most major Linux distributions. See instructions here: Flathub application page

If you have Flathub set up already:

flatpak install flathub io.github.antimicrox.antimicrox

❕ Flatpak package may not work correctly with wayland (Fix available here)

AppImage

Download from the release site.

It is recommended to use AppImageLauncher with this package.

Debian/Ubuntu-based distributions

Download from the release site and install .deb package.

Fedora

dnf install antimicrox

openSUSE

A package is available.

zypper install antimicrox

Arch Linux or Arch Linux based distributions:

trizen -S antimicrox

pre-built version can de downloaded from unofficial repository called chaotic-aur.

Append (one of listed mirrors) to /etc/pacman.conf:

# Brazil
Server = http://lonewolf-builder.duckdns.org/$repo/$arch
# Germany
Server = http://chaotic.bangl.de/$repo/$arch
# USA (Cloudflare cached)
Server = https://repo.kitsuna.net/$arch
# Netherlands
Server = https://chaotic.tn.dedyn.io/$arch

To check signature, add keys:

sudo pacman-key --keyserver hkp://keyserver.ubuntu.com -r 3056513887B78AEB 8A9E14A07010F7E3
sudo pacman-key --lsign-key 3056513887B78AEB
sudo pacman-key --lsign-key 8A9E14A07010F7E3

Install package

pacman -S antimicrox

Building Yourself

List of required dependencies and build instructions can be found here.

Packages status

Status of package antimicrox:

Command Line

Run antimicrox --help or read man antimicrox for command-line parameters.

Commandline for flatpak In case of flatpak package AntiMicroX can be launched with command:
flatpak run io.github.antimicrox.antimicrox instead of just antimicrox
In some cases it may be good to add alias
alias antimicrox='flatpak run io.github.antimicrox.antimicrox'
fo file ~/.bashrc

D-Bus

AntiMicroX provides a D-Bus service, io.github.antimicrox. You can control some
aspects of AntiMicroX using D-Bus, such as selecting the current control set.

For example, to select set 0 for input device 0 with dbus-send:

dbus-send --print-reply --dest=io.github.antimicrox /InputDevice/0 io.github.antimicrox.InputDevice.setActiveSetNumber int32:0

Objects

AntiMicroX provides InputDevice objects with paths /InputDevice/<N>, where
<N> is the device index.

To find a device of interest, enumerate those objects and use getSDLName and
getDescription to identify the device.

Interfaces

InputDevice objects support the io.github.antimicrox.InputDevice interface.

Method: io.github.antimicrox.InputDevice.getSDLName()

getSDLName() provides the human-readable name of the device, such as "Microsoft Xbox 360 Controller" or "HORIPAD FPS for Nintendo Switch".

Method: io.github.antimicrox.InputDevice.getDescription()

getDescription() provides a detailed description of the device:

Index:            1
  UniqueID:         030081b85e0400008e020000100100001118654
  GUID:             030081b85e0400008e02000010010000
  VendorID:         1118
  ProductID:        654
  Serial:
  Product Version:  272
  Name:             Xbox 360 Controller
  Game Controller: Yes
  # of RawAxes:    6
  # of Axes:       6
  # of RawButtons: 21
  # of Buttons:    21
  # of Hats:       0
  Accelerometer:   0
  Gyroscope:       0

This includes:

The controller's UniqueID assigned by AntiMicroX
The controller's GUID assigned by SDL
The controller's USB VendorID, ProductID, Serial, ProductVersion, and Name
Whether the device is a Game Controller
The controller's input features: # of RawAxes, # of Axes, # of RawButtons, # of Buttons, # of Hats, Accelerometer, and Gysroscope

Method: io.github.antimicrox.InputDevice.getActiveSetNumber()

getActiveSetNumber() returns the current set number for this device.

API set indices are 0-based, but they are displayed in the UI with 1-based
labels.

Method: io.github.antimicrox.InputDevice.getActiveSetName()

getActiveSetName() returns the name of the current set for this device.

This is empty if the set was not given a name. In that case, AntiMicroX
displays a default name: Set <N> with a 1-based index.

Method: io.github.antimicrox.InputDevice.setActiveSetNumber()

setActiveSetNumber() changes the active set for this device to the set
specified, as a 0-based index.

Test

Use D-Spy to inspect and test the D-Bus
interface.

Wiki

Look here

Testing Under Linux

If you are having problems with antimicrox detecting a controller or
detecting all axes and buttons, you should test the controller outside of
antimicrox to check if the problem is with antimicrox or not. The two endorsed
programs for testing gamepads outside of antimicrox are sdl-jstest
(sdl2-jstest) and evtest. SDL2 utilizes evdev on Linux so performing
testing with older programs that use joydev won't be as helpful since some
devices behave a bit differently between the two systems. Another method also exists,
which can be found here.

AntiMicroX Profiles

If you would like to send the profile you are using for your application or find something
for yourself, here is the forked repository. If you want to report a bug, ask
a question or share a suggestion, you can do that on the antimicrox page or on the
antimicrox-profiles page.

Support

There are several ways to get help with AntiMicroX. The easiest way is to upvote (with 👍) issues you thing are the most important ones.

Contributing

Any contributions into codebase are welcome. You can find contribution guide here.

Some issues are may have bounties which are meant to attract contributors.

Translation

Translation process is handled via Weblate. If you want to help just click this link.

Translation status

More information about translating can be found here.

terminals 4

classccai — Fri, 24 Apr 2026 07:08:29 +0000

Terminals Project

Terminals is a secure, multi tab terminal services/remote desktop client. RDP, VNC, VMRC, SSH, Telnet, RAS, ICA Citrix, HTTP and HTTPs based protocols are integrated. It uses Terminal Services ActiveX Client (mstscax.dll). The project started from the need of controlling multiple connections simultaneously. It is a complete replacement for the mstsc.exe (Terminal Services) client. This is official source moved from Codeplex. See features list

Downloads

News

October 2022 NOTE: Project RESURECTED, but we are still searching for maintainers!

February 2019 - Project is no longer under active development, we are searching for maintainers!
June 26, 2017 - New release version 4.0.1
May 17, 2017 - New record 40k downloads of version 4.0
April 5, 2017 - Road map for next features
April 2, 2017 - Version 4.0.0 release published New Options to disable protocol plugins
December 16,2016 - New Official Chocolatey package We are happy to announce that Chocolatey terminals package is now maintained by our team.

Donate

Keep the project Alive!

Documentation

User documentation
Installation
- System requirements
- Upgrade to version 3.0
Features and Screen shots
Developer guide (How to contribute)
Road map
Powershell script to create import file

License

fooocus

classccai — Fri, 24 Apr 2026 06:54:37 +0000

Fooocus

>>> Click Here to Install Fooocus <<<

Fooocus is an image generating software (based on Gradio ).

Fooocus presents a rethinking of image generator designs. The software is offline, open source, and free, while at the same time, similar to many online image generators like Midjourney, the manual tweaking is not needed, and users only need to focus on the prompts and images. Fooocus has also simplified the installation: between pressing "download" and generating the first image, the number of needed mouse clicks is strictly limited to less than 3. Minimal GPU memory requirement is 4GB (Nvidia).

Recently many fake websites exist on Google when you search “fooocus”. Do not trust those – here is the only official source of Fooocus.

Project Status: Limited Long-Term Support (LTS) with Bug Fixes Only

The Fooocus project, built entirely on the Stable Diffusion XL architecture, is now in a state of limited long-term support (LTS) with bug fixes only. As the existing functionalities are considered as nearly free of programmartic issues (Thanks to mashb1t's huge efforts), future updates will focus exclusively on addressing any bugs that may arise.

There are no current plans to migrate to or incorporate newer model architectures. However, this may change during time with the development of open-source community. For example, if the community converge to one single dominant method for image generation (which may really happen in half or one years given the current status), Fooocus may also migrate to that exact method.

For those interested in utilizing newer models such as Flux, we recommend exploring alternative platforms such as WebUI Forge (also from us), ComfyUI/SwarmUI. Additionally, several excellent forks of Fooocus are available for experimentation.

Again, recently many fake websites exist on Google when you search “fooocus”. Do NOT get Fooocus from those websites – this page is the only official source of Fooocus. We never have any website like such as “fooocus.com”, “fooocus.net”, “fooocus.co”, “fooocus.ai”, “fooocus.org”, “fooocus.pro”, “fooocus.one”. Those websites are ALL FAKE. They have ABSOLUTLY no relationship to us. Fooocus is a 100% non-commercial offline open-source software.

Features

Below is a quick list using Midjourney's examples:

Midjourney	Fooocus
High-quality text-to-image without needing much prompt engineering or parameter tuning. (Unknown method)	High-quality text-to-image without needing much prompt engineering or parameter tuning. (Fooocus has an offline GPT-2 based prompt processing engine and lots of sampling improvements so that results are always beautiful, no matter if your prompt is as short as “house in garden” or as long as 1000 words)
V1 V2 V3 V4	Input Image -> Upscale or Variation -> Vary (Subtle) / Vary (Strong)
U1 U2 U3 U4	Input Image -> Upscale or Variation -> Upscale (1.5x) / Upscale (2x)
Inpaint / Up / Down / Left / Right (Pan)	Input Image -> Inpaint or Outpaint -> Inpaint / Up / Down / Left / Right (Fooocus uses its own inpaint algorithm and inpaint models so that results are more satisfying than all other software that uses standard SDXL inpaint method/model)
Image Prompt	Input Image -> Image Prompt (Fooocus uses its own image prompt algorithm so that result quality and prompt understanding are more satisfying than all other software that uses standard SDXL methods like standard IP-Adapters or Revisions)
--style	Advanced -> Style
--stylize	Advanced -> Advanced -> Guidance
--niji	Multiple launchers: "run.bat", "run_anime.bat", and "run_realistic.bat". Fooocus support SDXL models on Civitai (You can google search “Civitai” if you do not know about it)
--quality	Advanced -> Quality
--repeat	Advanced -> Image Number
Multi Prompts (::)	Just use multiple lines of prompts
Prompt Weights	You can use " I am (happy:1.5)". Fooocus uses A1111's reweighting algorithm so that results are better than ComfyUI if users directly copy prompts from Civitai. (Because if prompts are written in ComfyUI's reweighting, users are less likely to copy prompt texts as they prefer dragging files) To use embedding, you can use "(embedding:file_name:1.1)"
--no	Advanced -> Negative Prompt
--ar	Advanced -> Aspect Ratios
InsightFace	Input Image -> Image Prompt -> Advanced -> FaceSwap
Describe	Input Image -> Describe

Below is a quick list using LeonardoAI's examples:

LeonardoAI	Fooocus
Prompt Magic	Advanced -> Style -> Fooocus V2
Advanced Sampler Parameters (like Contrast/Sharpness/etc)	Advanced -> Advanced -> Sampling Sharpness / etc
User-friendly ControlNets	Input Image -> Image Prompt -> Advanced

Also, click here to browse the advanced features.

Download

Windows

You can directly download Fooocus with:

>>> Click here to download <<<

After you download the file, please uncompress it and then run the "run.bat".

The first time you launch the software, it will automatically download models:

It will download default models to the folder "Fooocus\models\checkpoints" given different presets. You can download them in advance if you do not want automatic download.
Note that if you use inpaint, at the first time you inpaint an image, it will download Fooocus's own inpaint control model from here as the file "Fooocus\models\inpaint\inpaint_v26.fooocus.patch" (the size of this file is 1.28GB).

After Fooocus 2.1.60, you will also have run_anime.bat and run_realistic.bat. They are different model presets (and require different models, but they will be automatically downloaded). Check here for more details.

After Fooocus 2.3.0 you can also switch presets directly in the browser. Keep in mind to add these arguments if you want to change the default behavior:

Use --disable-preset-selection to disable preset selection in the browser.
Use --always-download-new-model to download missing models on preset switch. Default is fallback to previous_default_models defined in the corresponding preset, also see terminal output.

If you already have these files, you can copy them to the above locations to speed up installation.

Note that if you see "MetadataIncompleteBuffer" or "PytorchStreamReader", then your model files are corrupted. Please download models again.

Below is a test on a relatively low-end laptop with 16GB System RAM and 6GB VRAM (Nvidia 3060 laptop). The speed on this machine is about 1.35 seconds per iteration. Pretty impressive – nowadays laptops with 3060 are usually at very acceptable price.

Besides, recently many other software report that Nvidia driver above 532 is sometimes 10x slower than Nvidia driver 531. If your generation time is very long, consider download Nvidia Driver 531 Laptop or Nvidia Driver 531 Desktop.

Note that the minimal requirement is 4GB Nvidia GPU memory (4GB VRAM) and 8GB system memory (8GB RAM). This requires using Microsoft’s Virtual Swap technique, which is automatically enabled by your Windows installation in most cases, so you often do not need to do anything about it. However, if you are not sure, or if you manually turned it off (would anyone really do that?), or if you see any "RuntimeError: CPUAllocator", you can enable it here:

Click here to see the image instructions.

And make sure that you have at least 40GB free space on each drive if you still see "RuntimeError: CPUAllocator" !

Please open an issue if you use similar devices but still cannot achieve acceptable performances.

Note that the minimal requirement for different platforms is different.

See also the common problems and troubleshoots here.

Colab

(Last tested - 2024 Aug 12 by mashb1t)

Colab	Info
	Fooocus Official

In Colab, you can modify the last line to !python entry_with_update.py --share --always-high-vram or !python entry_with_update.py --share --always-high-vram --preset anime or !python entry_with_update.py --share --always-high-vram --preset realistic for Fooocus Default/Anime/Realistic Edition.

You can also change the preset in the UI. Please be aware that this may lead to timeouts after 60 seconds. If this is the case, please wait until the download has finished, change the preset to initial and back to the one you've selected or reload the page.

Note that this Colab will disable refiner by default because Colab free's resources are relatively limited (and some "big" features like image prompt may cause free-tier Colab to disconnect). We make sure that basic text-to-image is always working on free-tier Colab.

Using --always-high-vram shifts resource allocation from RAM to VRAM and achieves the overall best balance between performance, flexibility and stability on the default T4 instance. Please find more information here.

Thanks to camenduru for the template!

Linux (Using Anaconda)

If you want to use Anaconda/Miniconda, you can

git clone https://github.com/lllyasviel/Fooocus.git
cd Fooocus
conda env create -f environment.yaml
conda activate fooocus
pip install -r requirements_versions.txt

Then download the models: download default models to the folder "Fooocus\models\checkpoints". Or let Fooocus automatically download the models using the launcher:

conda activate fooocus
python entry_with_update.py

Or, if you want to open a remote port, use

conda activate fooocus
python entry_with_update.py --listen

Use python entry_with_update.py --preset anime or python entry_with_update.py --preset realistic for Fooocus Anime/Realistic Edition.

Linux (Using Python Venv)

Your Linux needs to have Python 3.10 installed, and let's say your Python can be called with the command python3 with your venv system working; you can

git clone https://github.com/lllyasviel/Fooocus.git
cd Fooocus
python3 -m venv fooocus_env
source fooocus_env/bin/activate
pip install -r requirements_versions.txt

See the above sections for model downloads. You can launch the software with:

source fooocus_env/bin/activate
python entry_with_update.py

Or, if you want to open a remote port, use

source fooocus_env/bin/activate
python entry_with_update.py --listen

Use python entry_with_update.py --preset anime or python entry_with_update.py --preset realistic for Fooocus Anime/Realistic Edition.

Linux (Using native system Python)

If you know what you are doing, and your Linux already has Python 3.10 installed, and your Python can be called with the command python3 (and Pip with pip3), you can

git clone https://github.com/lllyasviel/Fooocus.git
cd Fooocus
pip3 install -r requirements_versions.txt

See the above sections for model downloads. You can launch the software with:

python3 entry_with_update.py

Or, if you want to open a remote port, use

python3 entry_with_update.py --listen

Use python entry_with_update.py --preset anime or python entry_with_update.py --preset realistic for Fooocus Anime/Realistic Edition.

Linux (AMD GPUs)

Note that the minimal requirement for different platforms is different.

Same with the above instructions. You need to change torch to the AMD version

pip uninstall torch torchvision torchaudio torchtext functorch xformers 
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.6

AMD is not intensively tested, however. The AMD support is in beta.

Use python entry_with_update.py --preset anime or python entry_with_update.py --preset realistic for Fooocus Anime/Realistic Edition.

Windows (AMD GPUs)

Note that the minimal requirement for different platforms is different.

Same with Windows. Download the software and edit the content of run.bat as:

.\python_embeded\python.exe -m pip uninstall torch torchvision torchaudio torchtext functorch xformers -y
.\python_embeded\python.exe -m pip install torch-directml
.\python_embeded\python.exe -s Fooocus\entry_with_update.py --directml
pause

Then run the run.bat.

AMD is not intensively tested, however. The AMD support is in beta.

For AMD, use .\python_embeded\python.exe Fooocus\entry_with_update.py --directml --preset anime or .\python_embeded\python.exe Fooocus\entry_with_update.py --directml --preset realistic for Fooocus Anime/Realistic Edition.

Mac

Note that the minimal requirement for different platforms is different.

Mac is not intensively tested. Below is an unofficial guideline for using Mac. You can discuss problems here.

You can install Fooocus on Apple Mac silicon (M1 or M2) with macOS 'Catalina' or a newer version. Fooocus runs on Apple silicon computers via PyTorch MPS device acceleration. Mac Silicon computers don't come with a dedicated graphics card, resulting in significantly longer image processing times compared to computers with dedicated graphics cards.

Install the conda package manager and pytorch nightly. Read the Accelerated PyTorch training on Mac Apple Developer guide for instructions. Make sure pytorch recognizes your MPS device.
Open the macOS Terminal app and clone this repository with git clone https://github.com/lllyasviel/Fooocus.git.
Change to the new Fooocus directory, cd Fooocus.
Create a new conda environment, conda env create -f environment.yaml.
Activate your new conda environment, conda activate fooocus.
Install the packages required by Fooocus, pip install -r requirements_versions.txt.
Launch Fooocus by running python entry_with_update.py. (Some Mac M2 users may need python entry_with_update.py --disable-offload-from-vram to speed up model loading/unloading.) The first time you run Fooocus, it will automatically download the Stable Diffusion SDXL models and will take a significant amount of time, depending on your internet connection.

Use python entry_with_update.py --preset anime or python entry_with_update.py --preset realistic for Fooocus Anime/Realistic Edition.

Docker

See docker.md

Download Previous Version

See the guidelines here.

Minimal Requirement

Below is the minimal requirement for running Fooocus locally. If your device capability is lower than this spec, you may not be able to use Fooocus locally. (Please let us know, in any case, if your device capability is lower but Fooocus still works.)

Operating System	GPU	Minimal GPU Memory	Minimal System Memory	System Swap	Note
Windows/Linux	Nvidia RTX 4XXX	4GB	8GB	Required	fastest
Windows/Linux	Nvidia RTX 3XXX	4GB	8GB	Required	usually faster than RTX 2XXX
Windows/Linux	Nvidia RTX 2XXX	4GB	8GB	Required	usually faster than GTX 1XXX
Windows/Linux	Nvidia GTX 1XXX	8GB (&ast; 6GB uncertain)	8GB	Required	only marginally faster than CPU
Windows/Linux	Nvidia GTX 9XX	8GB	8GB	Required	faster or slower than CPU
Windows/Linux	Nvidia GTX < 9XX	Not supported	/	/	/
Windows	AMD GPU	8GB (updated 2023 Dec 30)	8GB	Required	via DirectML (&ast; ROCm is on hold), about 3x slower than Nvidia RTX 3XXX
Linux	AMD GPU	8GB	8GB	Required	via ROCm, about 1.5x slower than Nvidia RTX 3XXX
Mac	M1/M2 MPS	Shared	Shared	Shared	about 9x slower than Nvidia RTX 3XXX
Windows/Linux/Mac	only use CPU	0GB	32GB	Required	about 17x slower than Nvidia RTX 3XXX

&ast; AMD GPU ROCm (on hold): The AMD is still working on supporting ROCm on Windows.

&ast; Nvidia GTX 1XXX 6GB uncertain: Some people report 6GB success on GTX 10XX, but some other people report failure cases.

Note that Fooocus is only for extremely high quality image generating. We will not support smaller models to reduce the requirement and sacrifice result quality.

Troubleshoot

See the common problems here.

Default Models

Given different goals, the default models and configs of Fooocus are different:

Task	Windows	Linux args	Main Model	Refiner	Config
General	run.bat		juggernautXL_v8Rundiffusion	not used	here
Realistic	run_realistic.bat	--preset realistic	realisticStockPhoto_v20	not used	here
Anime	run_anime.bat	--preset anime	animaPencilXL_v500	not used	here

Note that the download is automatic - you do not need to do anything if the internet connection is okay. However, you can download them manually if you (or move them from somewhere else) have your own preparation.

UI Access and Authentication

In addition to running on localhost, Fooocus can also expose its UI in two ways:

Local UI listener: use --listen (specify port e.g. with --port 8888).
API access: use --share (registers an endpoint at .gradio.live).

In both ways the access is unauthenticated by default. You can add basic authentication by creating a file called auth.json in the main directory, which contains a list of JSON objects with the keys user and pass (see example in auth-example.json).

List of "Hidden" Tricks

Click to see a list of tricks. Those are based on SDXL and are not very up-to-date with latest models.

GPT2-based prompt expansion as a dynamic style "Fooocus V2". (similar to Midjourney's hidden pre-processing and "raw" mode, or the LeonardoAI's Prompt Magic).
Native refiner swap inside one single k-sampler. The advantage is that the refiner model can now reuse the base model's momentum (or ODE's history parameters) collected from k-sampling to achieve more coherent sampling. In Automatic1111's high-res fix and ComfyUI's node system, the base model and refiner use two independent k-samplers, which means the momentum is largely wasted, and the sampling continuity is broken. Fooocus uses its own advanced k-diffusion sampling that ensures seamless, native, and continuous swap in a refiner setup. (Update Aug 13: Actually, I discussed this with Automatic1111 several days ago, and it seems that the “native refiner swap inside one single k-sampler” is merged into the dev branch of webui. Great!)
Negative ADM guidance. Because the highest resolution level of XL Base does not have cross attentions, the positive and negative signals for XL's highest resolution level cannot receive enough contrasts during the CFG sampling, causing the results to look a bit plastic or overly smooth in certain cases. Fortunately, since the XL's highest resolution level is still conditioned on image aspect ratios (ADM), we can modify the adm on the positive/negative side to compensate for the lack of CFG contrast in the highest resolution level. (Update Aug 16, the IOS App Draw Things will support Negative ADM Guidance. Great!)
We implemented a carefully tuned variation of Section 5.1 of "Improving Sample Quality of Diffusion Models Using Self-Attention Guidance". The weight is set to very low, but this is Fooocus's final guarantee to make sure that the XL will never yield an overly smooth or plastic appearance (examples here). This can almost eliminate all cases for which XL still occasionally produces overly smooth results, even with negative ADM guidance. (Update 2023 Aug 18, the Gaussian kernel of SAG is changed to an anisotropic kernel for better structure preservation and fewer artifacts.)
We modified the style templates a bit and added the "cinematic-default".
We tested the "sd_xl_offset_example-lora_1.0.safetensors" and it seems that when the lora weight is below 0.5, the results are always better than XL without lora.
The parameters of samplers are carefully tuned.
Because XL uses positional encoding for generation resolution, images generated by several fixed resolutions look a bit better than those from arbitrary resolutions (because the positional encoding is not very good at handling int numbers that are unseen during training). This suggests that the resolutions in UI may be hard coded for best results.
Separated prompts for two different text encoders seem unnecessary. Separated prompts for the base model and refiner may work, but the effects are random, and we refrain from implementing this.
The DPM family seems well-suited for XL since XL sometimes generates overly smooth texture, but the DPM family sometimes generates overly dense detail in texture. Their joint effect looks neutral and appealing to human perception.
A carefully designed system for balancing multiple styles as well as prompt expansion.
Using automatic1111's method to normalize prompt emphasizing. This significantly improves results when users directly copy prompts from civitai.
The joint swap system of the refiner now also supports img2img and upscale in a seamless way.
CFG Scale and TSNR correction (tuned for SDXL) when CFG is bigger than 10.

Customization

After the first time you run Fooocus, a config file will be generated at Fooocus\config.txt. This file can be edited to change the model path or default parameters.

For example, an edited Fooocus\config.txt (this file will be generated after the first launch) may look like this:

{
    "path_checkpoints": "D:\\Fooocus\\models\\checkpoints",
    "path_loras": "D:\\Fooocus\\models\\loras",
    "path_embeddings": "D:\\Fooocus\\models\\embeddings",
    "path_vae_approx": "D:\\Fooocus\\models\\vae_approx",
    "path_upscale_models": "D:\\Fooocus\\models\\upscale_models",
    "path_inpaint": "D:\\Fooocus\\models\\inpaint",
    "path_controlnet": "D:\\Fooocus\\models\\controlnet",
    "path_clip_vision": "D:\\Fooocus\\models\\clip_vision",
    "path_fooocus_expansion": "D:\\Fooocus\\models\\prompt_expansion\\fooocus_expansion",
    "path_outputs": "D:\\Fooocus\\outputs",
    "default_model": "realisticStockPhoto_v10.safetensors",
    "default_refiner": "",
    "default_loras": [["lora_filename_1.safetensors", 0.5], ["lora_filename_2.safetensors", 0.5]],
    "default_cfg_scale": 3.0,
    "default_sampler": "dpmpp_2m",
    "default_scheduler": "karras",
    "default_negative_prompt": "low quality",
    "default_positive_prompt": "",
    "default_styles": [
        "Fooocus V2",
        "Fooocus Photograph",
        "Fooocus Negative"
    ]
}

Many other keys, formats, and examples are in Fooocus\config_modification_tutorial.txt (this file will be generated after the first launch).

Consider twice before you really change the config. If you find yourself breaking things, just delete Fooocus\config.txt. Fooocus will go back to default.

A safer way is just to try "run_anime.bat" or "run_realistic.bat" - they should already be good enough for different tasks.

~Note that user_path_config.txt is deprecated and will be removed soon.~ (Edit: it is already removed.)

All CMD Flags

entry_with_update.py  [-h] [--listen [IP]] [--port PORT]
                      [--disable-header-check [ORIGIN]]
                      [--web-upload-size WEB_UPLOAD_SIZE]
                      [--hf-mirror HF_MIRROR]
                      [--external-working-path PATH [PATH ...]]
                      [--output-path OUTPUT_PATH]
                      [--temp-path TEMP_PATH] [--cache-path CACHE_PATH]
                      [--in-browser] [--disable-in-browser]
                      [--gpu-device-id DEVICE_ID]
                      [--async-cuda-allocation | --disable-async-cuda-allocation]
                      [--disable-attention-upcast]
                      [--all-in-fp32 | --all-in-fp16]
                      [--unet-in-bf16 | --unet-in-fp16 | --unet-in-fp8-e4m3fn | --unet-in-fp8-e5m2]
                      [--vae-in-fp16 | --vae-in-fp32 | --vae-in-bf16]
                      [--vae-in-cpu]
                      [--clip-in-fp8-e4m3fn | --clip-in-fp8-e5m2 | --clip-in-fp16 | --clip-in-fp32]
                      [--directml [DIRECTML_DEVICE]]
                      [--disable-ipex-hijack]
                      [--preview-option [none,auto,fast,taesd]]
                      [--attention-split | --attention-quad | --attention-pytorch]
                      [--disable-xformers]
                      [--always-gpu | --always-high-vram | --always-normal-vram | --always-low-vram | --always-no-vram | --always-cpu [CPU_NUM_THREADS]]
                      [--always-offload-from-vram]
                      [--pytorch-deterministic] [--disable-server-log]
                      [--debug-mode] [--is-windows-embedded-python]
                      [--disable-server-info] [--multi-user] [--share]
                      [--preset PRESET] [--disable-preset-selection]
                      [--language LANGUAGE]
                      [--disable-offload-from-vram] [--theme THEME]
                      [--disable-image-log] [--disable-analytics]
                      [--disable-metadata] [--disable-preset-download]
                      [--disable-enhance-output-sorting]
                      [--enable-auto-describe-image]
                      [--always-download-new-model]
                      [--rebuild-hash-cache [CPU_NUM_THREADS]]

Inline Prompt Features

Wildcards

Example prompt: __color__ flower

Processed for positive and negative prompt.

Selects a random wildcard from a predefined list of options, in this case the wildcards/color.txt file.
The wildcard will be replaced with a random color (randomness based on seed).
You can also disable randomness and process a wildcard file from top to bottom by enabling the checkbox Read wildcards in order in Developer Debug Mode.

Wildcards can be nested and combined, and multiple wildcards can be used in the same prompt (example see wildcards/color_flower.txt).

Array Processing

Example prompt: [[red, green, blue]] flower

Processed only for positive prompt.

Processes the array from left to right, generating a separate image for each element in the array. In this case 3 images would be generated, one for each color.
Increase the image number to 3 to generate all 3 variants.

Arrays can not be nested, but multiple arrays can be used in the same prompt.
Does support inline LoRAs as array elements!

Inline LoRAs

Example prompt: flower <lora:sunflowers:1.2>

Processed only for positive prompt.

Applies a LoRA to the prompt. The LoRA file must be located in the models/loras directory.

Advanced Features

Click here to browse the advanced features.

Forks

Below are some Forks to Fooocus:

Fooocus' forks
fenneishi/Fooocus-Control runew0lf/RuinedFooocus MoonRide303/Fooocus-MRE mashb1t/Fooocus and so on ...

Thanks

Many thanks to twri and 3Diva and Marc K3nt3L for creating additional SDXL styles available in Fooocus.

The project starts from a mixture of Stable Diffusion WebUI and ComfyUI codebases.

Also, thanks daswer123 for contributing the Canvas Zoom!

Update Log

The log is here.

Localization/Translation/I18N

You can put json files in the language folder to translate the user interface.

For example, below is the content of Fooocus/language/example.json:

{
  "Generate": "生成",
  "Input Image": "入力画像",
  "Advanced": "고급",
  "SAI 3D Model": "SAI 3D Modèle"
}

If you add --language example arg, Fooocus will read Fooocus/language/example.json to translate the UI.

For example, you can edit the ending line of Windows run.bat as

.\python_embeded\python.exe -s Fooocus\entry_with_update.py --language example

Or run_anime.bat as

.\python_embeded\python.exe -s Fooocus\entry_with_update.py --language example --preset anime

Or run_realistic.bat as

.\python_embeded\python.exe -s Fooocus\entry_with_update.py --language example --preset realistic

For practical translation, you may create your own file like Fooocus/language/jp.json or Fooocus/language/cn.json and then use flag --language jp or --language cn. Apparently, these files do not exist now. We need your help to create these files!

Note that if no --language is given and at the same time Fooocus/language/default.json exists, Fooocus will always load Fooocus/language/default.json for translation. By default, the file Fooocus/language/default.json does not exist.

waf-fle

classccai — Fri, 24 Apr 2026 06:52:30 +0000

WAF-FLE - Readme

Web Application Firewall: Fast Log and Event Console

Copyright (C) 2011 - 2014 Klaubert Herr
For new (released) versions, check at http://waf-fle.org
WAF-FLE is relased under GPL v2 License

SUMMARY:

WAF-FLE is a OpenSource ModSecurity Console, allows modsecurity admin
to store, view and search events sent by sensors using a graphical
dashboard to drill-down and find quickly the most relevant events. It
is designed to be fast and flexible, while keeping a powerful and easy
to use filter, with almost all fields clickable to use on filter.

Features

Central event console
Support Modsecurity in “traditional” and “Anomaly Scoring”
Brings mlog2waffle as a replacement to mlogc
Receive events using mlog2waffle or mlogc
- mlog2waffle: in real-time, following log tail, or batch scheduled in crontab
- mlogc: in real-time, piped with ModSecurity log, in batch scheduled in crontab
No sensor limit
Drill down of events with filter
Dashboard with recent events information
Almost every event data and charts are “clickable” deepening the drill down filter
Inverted filter (to filter for “all but this item”)
Filter for network (in CIDR format, x.x.x.x/22)
Original format (Raw) to event download
Use Mysql as database
Wizard to help configure log feed between ModSecurity sensors and WAF-FLE
Open Source released under GPL v2

gh ost

classccai — Fri, 24 Apr 2026 06:41:17 +0000

gh-ost is a triggerless online schema migration solution for MySQL. It is testable and provides pausability, dynamic control/reconfiguration, auditing, and many operational perks.

gh-ost produces a light workload on the master throughout the migration, decoupled from the existing workload on the migrated table.

It has been designed based on years of experience with existing solutions, and changes the paradigm of table migrations.

How?

All existing online-schema-change tools operate in similar manner: they create a ghost table in the likeness of your original table, migrate that table while empty, slowly and incrementally copy data from your original table to the ghost table, meanwhile propagating ongoing changes (any INSERT, DELETE, UPDATE applied to your table) to the ghost table. Finally, at the right time, they replace your original table with the ghost table.

gh-ost uses the same pattern. However it differs from all existing tools by not using triggers. We have recognized the triggers to be the source of many limitations and risks.

Instead, gh-ost uses the binary log stream to capture table changes, and asynchronously applies them onto the ghost table. gh-ost takes upon itself some tasks that other tools leave for the database to perform. As result, gh-ost has greater control over the migration process; can truly suspend it; can truly decouple the migration's write load from the master's workload.

In addition, it offers many operational perks that make it safer, trustworthy and fun to use.

Highlights

Build your trust in gh-ost by testing it on replicas. gh-ost will issue same flow as it would have on the master, to migrate a table on a replica, without actually replacing the original table, leaving the replica with two tables you can then compare and satisfy yourself that the tool operates correctly. This is how we continuously test gh-ost in production.
True pause: when gh-ost throttles, it truly ceases writes on master: no row copies and no ongoing events processing. By throttling, you return your master to its original workload
Dynamic control: you can interactively reconfigure gh-ost, even as migration still runs. You may forcibly initiate throttling.
Auditing: you may query gh-ost for status. gh-ost listens on unix socket or TCP.
Control over cut-over phase: gh-ost can be instructed to postpone what is probably the most critical step: the swap of tables, until such time that you're comfortably available. No need to worry about ETA being outside office hours.
External hooks can couple gh-ost with your particular environment.

Please refer to the docs for more information. No, really, read the docs.

Usage

The cheatsheet has it all. You may be interested in invoking gh-ost in various modes:

a noop migration (merely testing that the migration is valid and good to go)
a real migration, utilizing a replica (the migration runs on the master; gh-ost figures out identities of servers involved. Required mode if your master uses Statement Based Replication)
a real migration, run directly on the master (but gh-ost prefers the former)
a real migration on a replica (master untouched)
a test migration on a replica, the way for you to build trust with gh-ost's operation.

Our tips:

Testing above all, try out --test-on-replica first few times. Better yet, make it continuous. We have multiple replicas where we iterate our entire fleet of production tables, migrating them one by one, checksumming the results, verifying migration is good.
For each master migration, first issue a noop
Then issue the real thing via --execute.

More tips:

Use --exact-rowcount for accurate progress indication
Use --postpone-cut-over-flag-file to gain control over cut-over timing
Get familiar with the interactive commands

Also see:

What's in a name?

Originally this was named gh-osc: GitHub Online Schema Change, in the likes of Facebook online schema change and pt-online-schema-change.

But then a rare genetic mutation happened, and the c transformed into t. And that sent us down the path of trying to figure out a new acronym. gh-ost (pronounce: Ghost), stands for GitHub's Online Schema Transmogrifier/Translator/Transformer/Transfigurator

License

gh-ost is licensed under the MIT license

gh-ost uses 3rd party libraries, each with their own license. These are found here.

Community

gh-ost is released at a stable state, but with mileage to go. We are open to pull requests. Please first discuss your intentions via Issues.

We develop gh-ost at GitHub and for the community. We may have different priorities than others. From time to time we may suggest a contribution that is not on our immediate roadmap but which may appeal to others.

Please see Coding gh-ost for a guide to getting started developing with gh-ost.

Download/binaries/source

gh-ost is now GA and stable.

gh-ost is available in binary format for Linux and Mac OS/X

Download latest release here

gh-ost is a Go project; it is built with Go 1.15 and above. To build on your own, use either:

script/build - this is the same build script used by CI hence the authoritative; artifact is ./bin/gh-ost binary.
build.sh for building tar.gz artifacts in /tmp/gh-ost-release

Generally speaking, master branch is stable, but only releases are to be used in production.

Authors

gh-ost is designed, authored, reviewed and tested by the database infrastructure team at GitHub:

openstock

classccai — Fri, 24 Apr 2026 06:40:09 +0000

OpenStock is an open-source alternative to expensive market platforms. Track real-time prices, set personalized alerts, and explore detailed company insights — built openly, for everyone, forever free.

Note: OpenStock is community-built and not a brokerage. Market data may be delayed based on provider rules and your configuration. Nothing here is financial advice.

📋 Table of Contents

✨ Introduction
🌍 Open Dev Society Manifesto
⚙️ Tech Stack
🔋 Features
🤸 Quick Start
🐳 Docker Setup
🔐 Environment Variables
🧱 Project Structure
📡 Data & Integrations
🧪 Scripts & Tooling
🤝 Contributing
🛡️ Security
📜 License
🙏 Acknowledgements

✨ Introduction

OpenStock is a modern stock market app powered by Next.js (App Router), shadcn/ui and Tailwind CSS, Better Auth for authentication, MongoDB for persistence, Finnhub for market data, and TradingView widgets for charts and market views.

🌍 Open Dev Society Manifesto

We live in a world where knowledge is hidden behind paywalls. Where tools are locked in subscriptions. Where information is twisted by bias. Where newcomers are told they’re not “good enough” to build.

We believe there’s a better way.

Our Belief: Technology should belong to everyone. Knowledge should be open, free, and accessible. Communities should welcome newcomers with trust, not gatekeeping.
Our Mission: Build free, open-source projects that make a real difference:
- Tools that professionals and students can use without barriers.
- Knowledge platforms where learning is free, forever.
- Communities where every beginner is guided, not judged.
- Resources that run on trust, not profit.
Our Promise: We will never lock knowledge. We will never charge for access. We will never trade trust for money. We run on transparency, donations, and the strength of our community.
Our Call: If you’ve ever felt you didn’t belong, struggled to find free resources, or wanted to build something meaningful — you belong here.

Because the future belongs to those who build it openly.

⚙️ Tech Stack

Core

Next.js 15 (App Router), React 19
TypeScript
Tailwind CSS v4 (via @tailwindcss/postcss)
shadcn/ui + Radix UI primitives
Lucide icons

Auth & Data

Better Auth (email/password) with MongoDB adapter
MongoDB + Mongoose
Finnhub API for symbols, profiles, and market news
TradingView embeddable widgets

Automation & Comms

Inngest (events, cron, AI inference via Gemini)
Nodemailer (Gmail transport)
next-themes, cmdk (command palette), react-hook-form

Language composition

TypeScript (~93.4%), CSS (~6%), JavaScript (~0.6%)

🔋 Features

Authentication
- Email/password auth with Better Auth + MongoDB adapter
- Protected routes enforced via Next.js middleware
Global search and Command + K palette
- Fast stock search backed by Finnhub
- Popular stocks when idle; debounced querying
Watchlist
- Per-user watchlist stored in MongoDB (unique symbol per user)
Stock details
- TradingView symbol info, candlestick/advanced charts, baseline, technicals
- Company profile and financials widgets
- Optional cross-source sentiment insights for Reddit, X.com, news, and Polymarket
Market overview
- Heatmap, quotes, and top stories (TradingView widgets)
Personalized onboarding
- Collects country, investment goals, risk tolerance, preferred industry
Email & automation
- AI-personalized welcome email (Gemini via Inngest)
- Daily news summary emails (cron) personalized using user watchlists
Polished UI
- shadcn/ui components, Radix primitives, Tailwind v4 design tokens
- Dark theme by default
Keyboard shortcut
- Cmd/Ctrl + K for quick actions/search

🤸 Quick Start

Prerequisites

Node.js 20+ and pnpm or npm
MongoDB connection string (MongoDB Atlas or local via Docker Compose)
Finnhub API key (free tier supported; real-time may require paid)
Gmail account for email (or update Nodemailer transport)
Optional: Google Gemini API key (for AI-generated welcome intros)

Clone and install

git clone https://github.com/Open-Dev-Society/OpenStock.git
cd OpenStock

# choose one:
pnpm install
# or
npm install

Configure environment

Create a .env file (see Environment Variables).
Verify DB connectivity:

pnpm test:db
# or
npm run test:db

Run development

# Next.js dev (Turbopack)
pnpm dev
# or
npm run dev

Run Inngest locally (workflows, cron, AI)

npx inngest-cli@latest dev

Build & start (production)

pnpm build && pnpm start
# or
npm run build && npm start

Open http://localhost:3000 to view the app.

🐳 Docker Setup

You can run OpenStock and MongoDB easily with Docker Compose.

1) Ensure Docker and Docker Compose are installed.

2) docker-compose.yml includes two services:

openstock (this app)
mongodb (MongoDB database with a persistent volume)

3) Create your .env (see examples below). For the Docker setup, use a local connection string like:

MONGODB_URI=mongodb://root:example@mongodb:27017/openstock?authSource=admin

4) Start the stack:

# from the repository root
docker compose up -d mongodb && docker compose up -d --build

5) Access the app:

App: http://localhost:3000
MongoDB is available inside the Docker network at host mongodb:27017

Notes

The app service depends_on the mongodb service.
Credentials are defined in Compose for the MongoDB root user; authSource=admin is required on the connection string for root.
Data persists across restarts via the docker volume.

Optional: Example MongoDB service definition used in this project:

services:
  mongodb:
    image: mongo:7
    container_name: mongodb
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: example
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  mongo-data:

🔐 Environment Variables

Create .env at the project root. Choose either a hosted MongoDB (Atlas) URI or the local Docker URI.

Hosted (MongoDB Atlas):

# Core
NODE_ENV=development

# Database (Atlas)
MONGODB_URI=mongodb+srv://<user>:<pass>@<cluster>/<db>?retryWrites=true&w=majority

# Better Auth
BETTER_AUTH_SECRET=your_better_auth_secret
BETTER_AUTH_URL=http://localhost:3000

# Finnhub
# Note: NEXT_PUBLIC_FINNHUB_API_KEY is required for Vercel deployment
NEXT_PUBLIC_FINNHUB_API_KEY=your_finnhub_key
FINNHUB_BASE_URL=https://finnhub.io/api/v1

# Sentiment insights (optional)
ADANOS_API_KEY=your_adanos_api_key
# ADANOS_API_BASE_URL=https://api.adanos.org

# AI Provider (optional, default: "gemini")
# Supported: "gemini", "minimax", "siray"
# AI_PROVIDER=gemini

# Gemini
GEMINI_API_KEY=your_gemini_api_key

# MiniMax (optional, used when AI_PROVIDER=minimax or as fallback)
# Get your key at https://platform.minimaxi.com
# MINIMAX_API_KEY=your_minimax_api_key

# Inngest Signing Key (required for Vercel deployment)
# Get this from your Inngest dashboard: https://app.inngest.com/env/settings/keys
INNGEST_SIGNING_KEY=your_inngest_signing_key

# Email (Nodemailer via Gmail; consider App Passwords if 2FA)
NODEMAILER_EMAIL=youraddress@gmail.com
NODEMAILER_PASSWORD=your_gmail_app_password

Local (Docker Compose) MongoDB:

# Core
NODE_ENV=development

# Database (Docker)
MONGODB_URI=mongodb://root:example@mongodb:27017/openstock?authSource=admin

# Better Auth
BETTER_AUTH_SECRET=your_better_auth_secret
BETTER_AUTH_URL=http://localhost:3000

# Finnhub
# Note: NEXT_PUBLIC_FINNHUB_API_KEY is required for Vercel deployment
NEXT_PUBLIC_FINNHUB_API_KEY=your_finnhub_key
FINNHUB_BASE_URL=https://finnhub.io/api/v1

# Sentiment insights (optional)
ADANOS_API_KEY=your_adanos_api_key
# ADANOS_API_BASE_URL=https://api.adanos.org

# AI Provider (optional, default: "gemini")
# Supported: "gemini", "minimax", "siray"
# AI_PROVIDER=gemini

# Gemini
GEMINI_API_KEY=your_gemini_api_key

# MiniMax (optional, used when AI_PROVIDER=minimax or as fallback)
# Get your key at https://platform.minimaxi.com
# MINIMAX_API_KEY=your_minimax_api_key

# Inngest Signing Key (required for Vercel deployment)
# Get this from your Inngest dashboard: https://app.inngest.com/env/settings/keys
INNGEST_SIGNING_KEY=your_inngest_signing_key

# Email (Nodemailer via Gmail; consider App Passwords if 2FA)
NODEMAILER_EMAIL=youraddress@gmail.com
NODEMAILER_PASSWORD=your_gmail_app_password

Notes

Keep private keys server-side whenever possible.
If using NEXT_PUBLIC_ variables, remember they are exposed to the browser.
In production, prefer a dedicated SMTP provider over a personal Gmail.
Do not hardcode secrets in the Dockerfile; use .env and Compose.

🧱 Project Structure

app/
  (auth)/
    layout.tsx
    sign-in/page.tsx
    sign-up/page.tsx
  (root)/
    layout.tsx
    page.tsx
    help/page.tsx
    stocks/[symbol]/page.tsx
  api/inngest/route.ts
  globals.css
  layout.tsx
components/
  ui/…          # shadcn/radix primitives (button, dialog, command, input, etc.)
  forms/…       # InputField, SelectField, CountrySelectField, FooterLink
  Header.tsx, Footer.tsx, SearchCommand.tsx, WatchlistButton.tsx, …
database/
  models/watchlist.model.ts
  mongoose.ts
lib/
  actions/…     # server actions (auth, finnhub, user, watchlist)
  better-auth/…
  inngest/…     # client, functions, prompts
  nodemailer/…  # transporter, email templates
  constants.ts, utils.ts
scripts/
  test-db.mjs
types/
  global.d.ts
next.config.ts          # i.ibb.co image domain allowlist
postcss.config.mjs      # Tailwind v4 postcss setup
components.json         # shadcn config
public/assets/images/   # logos and screenshots

📡 Data & Integrations

Finnhub
- Stock search, company profiles, and market news.
- Set NEXT_PUBLIC_FINNHUB_API_KEY and FINNHUB_BASE_URL (default: https://finnhub.io/api/v1).
- Free tiers may return delayed quotes; respect rate limits and terms.
Adanos sentiment insights (optional)
- Structured stock sentiment snapshots across Reddit, X.com, news, and Polymarket.
- Set ADANOS_API_KEY; optionally override the API host with ADANOS_API_BASE_URL.
- Used only for the stock detail sentiment card and does not replace Finnhub or TradingView.
TradingView
- Embeddable widgets used for charts, heatmap, quotes, and timelines.
- External images from i.ibb.co are allowlisted in next.config.ts.
Better Auth + MongoDB
- Email/password with MongoDB adapter.
- Session validation via middleware; most routes are protected, with public exceptions for sign-in, sign-up, assets and Next internals.
Inngest
- Workflows:
  - app/user.created → AI-personalized Welcome Email
  - Cron 0 12 * * * → Daily News Summary per user
- Local dev: npx inngest-cli@latest dev.
Email (Nodemailer)
- Gmail transport. Update credentials or switch to your SMTP provider.
- Templates for welcome and news summary emails.

🧪 Scripts & Tooling

Package scripts

dev: Next.js dev server with Turbopack
build: Production build (Turbopack)
start: Run production server
lint: ESLint
test:db: Validate DB connectivity

Developer experience

TypeScript strict mode
Tailwind CSS v4 (no separate tailwind.config needed)
shadcn/ui components with Radix primitives
cmdk command palette, next-themes, lucide-react icons

🤝 Contributing

You belong here. Whether you’re a student, a self-taught dev, or a seasoned engineer — contributions are welcome.

Open an issue to discuss ideas and bugs
Look for “good first issue” or “help wanted”
Keep PRs focused; add screenshots for UI changes
Be kind, guide beginners, no gatekeeping — that’s the ODS way

🛡️ Security

If you discover a vulnerability:

Do not open a public issue
Email: opendevsociety@cc.cc
We'll coordinate responsible disclosure and patch swiftly

📜 License

OpenStock is and will remain free and open for everyone. This project is licensed under the AGPL-3.0 License - see the LICENSE file for details.

🙏 Acknowledgements

Finnhub for accessible market data
TradingView for embeddable market widgets
shadcn/ui, Radix UI, Tailwind CSS, Next.js community
Inngest for dependable background jobs and workflows
Better Auth for simple and secure authentication
All contributors who make open tools possible

— Built openly, for everyone, forever free. Open Dev Society.

© Open Dev Society. This project is licensed under AGPL-3.0; if you modify, redistribute, or deploy it (including as a web service), you must release your source code under the same license and credit the original authors.

Our Honourable Contributors

ravixalgorithm - Developed the entire application from the ground up, including authentication, UI design, API and AI integration, and deployment.
Priyanshuu00007 - Created the official OpenStock logo and contributed to the project’s visual identity.
chinnsenn - Set up Docker configuration for the repository, ensuring a smooth development and deployment process.
koevoet1221 - Resolved MongoDB Docker build issues, improving the project’s overall stability and reliability.
ettoreciolli1 - updated Readme

❤️ Partners & Backers

Siray.ai — The robust AI infrastructure backing OpenStock. Siray.ai ensures our market insights never sleep.

Special thanks

Huge thanks to Adrian Hajdin (JavaScript Mastery) — his excellent Stock Market App tutorial was instrumental in building OpenStock for the open-source community under the Open Dev Society.

GitHub: adrianhajdin
YouTube tutorial: Stock Market App Tutorial
YouTube channel: JavaScript Mastery

gl go go-gl

classccai — Fri, 24 Apr 2026 06:21:28 +0000

gl

This repository holds Go bindings to various OpenGL versions. They are auto-generated using Glow.

Features:

Go functions that mirror the C specification using Go types.
Support for multiple OpenGL APIs (GL/GLES/EGL/WGL/GLX/EGL), versions, and profiles.
Support for extensions (including debug callbacks).

Requirements:

A cgo compiler (typically gcc).
On Ubuntu/Debian-based systems, the libgl1-mesa-dev package.

Usage

Use go get -u to download and install the prebuilt packages. The prebuilt packages support OpenGL versions 2.1, 3.1, 3.2, 3.3, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6 across both the core and compatibility profiles and include all extensions. Pick whichever one(s) you need:

go get -u github.com/go-gl/gl/v{3.2,3.3,4.1,4.2,4.3,4.4,4.5,4.6}-{core,compatibility}/gl
go get -u github.com/go-gl/gl/v3.1/gles2
go get -u github.com/go-gl/gl/v2.1/gl

Once the bindings are installed you can use them with the appropriate import statements.

package main

import "github.com/go-gl/gl/v3.3-core/gl"

func main() {
    window := ... // Open a window.
    window.MakeContextCurrent()

    // Important! Call gl.Init only under the presence of an active OpenGL context,
    // i.e., after MakeContextCurrent.
    if err := gl.Init(); err != nil {
        log.Fatalln(err)
    }
}

The gl package contains the OpenGL functions and enumeration values for the imported version. It also contains helper functions for working with the API. Of note is gl.Ptr which takes a Go array or slice or pointer and returns a corresponding uintptr to use with functions expecting data pointers. Also of note is gl.Str which takes a null-terminated Go string and returns a corresponding *int8 to use with functions expecting character pointers.

A note about threading and goroutines. The bindings do not expose a mechanism to make an OpenGL context current on a different thread so you must restrict your usage to the thread on which you called gl.Init(). To do so you should use LockOSThread.

Examples

Examples illustrating how to use the bindings are available in the example repo. There are examples for OpenGL 4.1 core and OpenGL 2.1.

Function Loading

The procaddr package contains platform-specific functions for loading OpenGL functions. Calling gl.Init() uses the auto subpackage to automatically select an appropriate implementation based on the build environment. If you want to select a specific implementation you can use the noauto build tag and the gl.InitWithProcAddrFunc initialization function.

Go >=1.14 and `checkptr`

In version 1.14 of Go, the race detector added checkptr instrumentation. This compilation option ensures that programs follow unsafe.Pointer safety rules. See here for details: https://golang.org/doc/go1.14#compiler.

If enabled, there is a high chance that it will cause program termination when calling specific OpenGL functions, with a message like this:

fatal error: checkptr: pointer arithmetic computed bad pointer value

The reported call stack will point to a function like gl.VertexAttribPointer() that receives an unsafe.Pointer as parameter.
In case such function requires an "offset" passed in as a pointer (in the low-level API), a different signature needs to be used in order to satisfy the detector.

For this purpose glow generates "override" functions which have a different signature, taking uintptr instead. These functions have the suffix WithOffset (or similar) in their name.
For the previous example, it would be gl.VertexAttribPointerWithOffset().

Not all such functions have an appropriate override! In case you stumble over such an error, and the override is missing, you have the following options:

Disable the detector by building your program with -gcflags=all=-d=checkptr=0
Report the missing function(s) as issue for glow
Possibly even create a pull-request for glow with the missing override yourself, and re-generate the gl bindings.

Generating

These gl bindings are generated using the Glow generator. Only developers of this repository need to do this step.

It is required to have glow source in a sibling directory to go-gl/gl since relative paths are used for generation (see generate.go).
For non-module-aware cases, this means glow needs to be in the same Go workspace as go-gl/gl.
For module-aware cases, go-gl/glow needs to be checked out parallel to go-gl/gl.

Perform generation with the following:

cd path/to/go-gl/gl
go generate -tags=gen .

More information about these bindings can be found in the Glow repository.

bython

classccai — Fri, 24 Apr 2026 06:20:06 +0000

Bython

Python with braces. Because Python is awesome, but whitespace is awful.

Bython is a Python preprosessor which translates curly brackets into indentation.

Content of README:

Key features
Code example
Installation
Quick intro
Structure of the repository

Key features

"Forget" about indentaition. You should still write beautiful code, but if you mess up with tabs/spaces, or copy one piece of code to another that uses a different indentation style, it won't break.
Uses Python for interpretation, that means that all of your existing modules, like NumPy and Matplotlib still works.

Code example

def print_message(num_of_times) {
    for i in range(num_of_times) {
        print("Bython is awesome!");
    }
}

if __name__ == "__main__" {
    print_message(10);
}

Installation

You can install Bython directly from PyPI using pip (with or without sudo -H, depending on your Python installation):

$ sudo -H pip3 install bython

If you for some reason want to install it from the git repository you can use git clone and do a local install instead:

$ git clone https://github.com/mathialo/bython.git
$ cd bython
$ sudo -H pip3 install .

The git version is sometimes a tiny bit ahead of the PyPI version, but not significantly.

To uninstall, simply run

$ sudo pip3 uninstall bython

which will undo all the changes.

Quick intro

Bython works by first translating Bython-files (suggested file ending: .by) into Python-files, and then using Python to run them. You therefore need a working installation of Python for Bython to work.

To run a Bython program, simply type

$ bython source.by arg1 arg2 ...

to run source.by with arg1, arg2, ... as command line arguments. If you want more details on how to run Bython files (flags, etc), type

$ bython -h

to print the built-in help page. You can also consult the man page by typing

$ man bython

Bython also includes a translator from Python to Bython. This is found via the py2by command:

$ py2by test.py

This will create a Bython file called test.by. A full explanation of py2by, is found by typing

$ py2by -h

or by consulting the man page:

$ man py2by

For a more in-depth intro, consult the bython introduction

Structure of the repository

At the moment, Bython is written in Python. The git repository is structured into 4 directories:

bython contains a Python package containing the parser and other utilities used by the main script
etc contains manual pages and other auxillary files
scripts contains the runnable Python scripts, ie the ones run from the shell
testcases contains a couple of sample *.by and *.py files intended for testing the implementation

catime

classccai — Fri, 24 Apr 2026 06:12:59 +0000

🎨 Powerful Tray Animations

Your tray icon can now come alive! Catime brings powerful custom animation features:

Custom Animations: Use GIF, WebP, and static images like PNG & JPG as your tray icon.
System Status: Supports real-time display of CPU %, Memory %, Battery %, and Caps Lock status.

[!TIP]
Looking for more fun animations? Check out our companion project, MemeTray!

💫Plugins

Plugins write to output.txt, Catime displays it — that simple.

[!TIP]
Looking for more useful Plugins? Check out our companion project, Catime-Plugins!

❤️‍🔥Staying tuned with us

Star us and witness how this pure C-crafted minimalist time tool continues to evolve - don't miss any exciting updates!

📥 Download

GitHub Releases

Download the latest release from GitHub Releases.

Winget
```
winget install --id VladElaina.Catime
```

📑User Guide

Left-click tray icon: Set time
Right-click tray icon: Set menu
Edit mode: Drag to adjust position, scroll wheel to resize, 🖱️ right-click to exit edit mode

Configuration file saved at %LOCALAPPDATA%\Catime\config.ini

⚡Font Optimization

Reduce custom font file size by 90%+ with the official Font Simplification Tool.

Since Catime only displays numbers and symbols (0-9, :, .), most font characters are unnecessary.

Recommendation: Keep your original font files as backups. Future software updates may require additional characters beyond the current set.

🛠️ Development

Prerequisites: MinGW and CMake are required to build Catime.

Getting Started

git clone https://github.com/vladelaina/Catime.git
cd Catime

# INSTALL DEPENDENCIES
# Ubuntu/Debian
sudo apt update && sudo apt install -y mingw-w64 cmake

# Arch Linux  
sudo pacman -Syu --noconfirm mingw-w64 cmake

# Windows - See setup instructions below

📋 Windows Setup Instructions

📦 Required Tools

Tool	Description	Recommended Version Format	Download Link
MinGW	GCC Compiler	`x86_64--release-win32-seh-ucrt-rtv-rev.7z`	MinGW Build
CMake	Build Tool	`cmake--windows-x86_64.msi`	CMake

🔧 Installation Steps

1. Install MinGW

Download x86_64--release-win32-seh-ucrt-rtv-rev.7z from MinGW Build
Extract to C:\mingw64
Add C:\mingw64\bin to your PATH environment variable:
- Open: Control Panel → System → Advanced System Settings → Environment Variables
- Find Path in System variables, click "Edit"
- Add: C:\mingw64\bin

2. Install CMake

Download and run cmake--windows-x86_64.msi from CMake
During installation, select "Add CMake to the system PATH"

3. Verify Installation

gcc --version
cmake --version

Building

chmod +x build.sh && ./build.sh   # Linux
build.bat                         # Windows

🎁 Support

src="https://github.com/user-attachments/assets/49035b18-e803-4ee8-9ea5-2e3f32f099de"
width="1889"
height="872"
alt="image"
/>

Project Status

🌟Star History

✨Acknowledgements

With special appreciation to 猫屋敷梨梨Official for the beautiful icon design.

Special thanks to the following contributors(chronological order):

MAX°孟兆

XuJilong

点滴进度作者

zggsong

猫屋敷梨梨Official

MOJIもら

李康

我是无名吖

金麟

双脚猫

rsyqvthv

君影

学习马楼

睡着的火山

星空下数羊

青阳忘川

William

王野

煮酒论科技

风增

田春

behappy425

x.j

kissholic

Alnilam

柒

枫谷剑仙

Marial

卓越方达

choyy

益渊Yyuan

上条教主

jin-gubang

xlr134

莫颜

LuSrackhall

是玄夜不是玄月

YangCangShu

valuex

lxzrjyff

DaYe

zct4257

小败叶

闲人不梦君Q

李良

imxhe

mua

析木

溜溜大神校长来了

Seredo

红树林

Snow-kal

TCWei

YuYinLC

Fireman

🗝️Copyright Notice

This project is released under the Apache License 2.0 open source license.

Icon copyright notice:

The software icon was created by 猫屋敷梨梨Official who reserves all rights. Without explicit authorization from the original creator, it may not be used for any commercial purposes.

Font licenses:

MIT:
- ProFontWindows Essence.ttf
SIL Open Font License:
- DaddyTimeMono Essence.otf, DepartureMono Essence.otf, Rec Mono Casual Essence.ttf, Terminess Nerd Font Essence.ttf
OFL (Open Font License):
- Jacquard 12 Essence.ttf, Jacquarda Bastarda 9 Essence.ttf, Pixelify Sans Essence.ttf, Rubik Burned Essence.ttf, Rubik Glitch Essence.ttf, Rubik Marker Hatch Essence.ttf, Rubik Puddles Essence.ttf, Wallpoet Essence.ttf

Wallpaper:

Author: 猫屋敷梨梨Official
- Dynamic wallpaper link: 猫屋敷梨梨「星之所在」曲绘夜晚版 & 猫屋敷梨梨-「星之所在」曲绘黄昏版

frins

classccai — Fri, 24 Apr 2026 06:11:38 +0000

Frins

Frins is a practical unit-of-measure calculator DSL for Scala.

Key features;

Tracks units of measure through all calculations allowing you to mix units of measure transparently
Comes with a huge database of units and conversion factors
Inspired by the Frink project and Frinj
Tries to combine Frink's fluent calculation style with idiomatic Scala

Artifacts

Add the following lines to your build.sbt

resolvers += "Sonatype snapshots" at "http://oss.sonatype.org/content/repositories/snapshots/"

libraryDependencies += "io.github.martintrojer" % "frins_2.10" % "0.1-SNAPSHOT"

Usage

Turn your sbt console into an (even more) powerful calculator;

$ sbt console
scala> import frins._
scala> initDatabases

You are now ready to go! Frins keeps it's values in instances of the Number class, which contains a Double value and a Map of Units. Once you have a Number object you can use it in calculations as you would normally use Doubles.

There are convenience Frins Number builders using the form N(value, 'unit, 'unit, ...) (value can be omitted) and implicits conversions from other number types and scala symbols (denoting the unit) to Frins Numbers.

scala> 'teaspoon * 'water * ('c ** 2)
res0: frins.Number[Double] = 4.429893807970541E14 m^2 kg s^-2 [energy]

That's the energy contained in one teaspoon of water (using E=mc^2). Wow, big number, how much is that "in real money"?

scala> res0 to 'gallons * 'gasoline
res1: frins.NumberT = 3164209.8628361006  [dimensionless]

There you have it, the energy in one teaspoon of water (according to Einstein) is equivalent to burning 3 million (!) gallons of gasoline.

For more examples and explanations of the Number builders (and more!) see the example calculations below.

Examples

See example calculations for ideas (and some laughs)...
Video of a Frinj talk (Frinj is Frins' sibling project)

Finally, check the wiki for more information.

License

Distributed under the Eclipse Public License.

minian

classccai — Fri, 24 Apr 2026 05:58:40 +0000

MiniAn

MiniAn is an analysis pipeline and visualization tool inspired by both CaImAn and MIN1PIPE package specifically for Miniscope data.

Quick Start Guide

Create a new conda env: conda create -y --name minian
Activate the environment: conda activate minian
Install MiniAn: conda install -y -c conda-forge minian
Install the pipeline notebooks: minian-install --notebooks
Optional install the demo movies: minian-install --demo
Fire up jupyter: jupyter notebook and open the notebook "pipeline.ipynb"

Documentation

MiniAn documentation is hosted on ReadtheDocs at:

https://minian.readthedocs.io/

Contributing to MiniAn

We would love feedback and contribution from the community!
See the contribution page for more detail!

License

This project is licensed under GNU GPLv3.

MAX°孟兆	XuJilong	点滴进度作者	zggsong	猫屋敷梨梨Official	MOJIもら	李康
我是无名吖	金麟	双脚猫	rsyqvthv	君影	学习马楼	睡着的火山
星空下数羊	青阳忘川	William	王野	煮酒论科技	风增	田春
behappy425	x.j	kissholic	Alnilam	柒	枫谷剑仙	Marial
卓越方达	choyy	益渊Yyuan	上条教主	jin-gubang	xlr134	莫颜
LuSrackhall	是玄夜不是玄月	YangCangShu	valuex	lxzrjyff	DaYe	zct4257
小败叶	闲人不梦君Q	李良	imxhe	mua	析木	溜溜大神校长来了
Seredo	红树林	Snow-kal	TCWei	YuYinLC	Fireman