AlgoX brings STL-style data structures and algorithms to Python with a native C backend.
AlgoX is a C-powered algorithms and data structures library for Python. It provides STL-inspired containers, generic algorithms, and low-overhead implementations designed for performance, learning, and experimentation.
]]>
Most machine learning frameworks present a black-box contract: data goes in, a trained model comes out. sklearn.linear_model.LinearRegression().fit(X, y) conceals the forward pass, the loss evaluation, the gradient computation, and the parameter update behind a single method call. While convenient for production, this opacity is antithetical to understanding.
TrueML adopts the opposite stance: zero abstraction. Every mathematical operation in the learning pipeline is a first-class function you invoke explicitly. The library provides the primitive operations; you write the protocol.
Every supervised learning experiment in TrueML follows this canonical sequence:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
┌─────────────────────────────────────────────────────────┐
│ TRAINING LOOP │
│ │
│ 1. FORWARD y_pred = model.forward(X) │
│ ŷ = Xw + b │
│ │
│ 2. LOSS error = loss_fn(y, y_pred) │
│ L = |y – ŷ| │
│ │
│ 3. GRADIENT dw, db = loss_fn.grad(X, error) │
│ ∂L/∂w = (1/n) Xᵀ · ∂L/∂ŷ │
│ │
│ 4. BACKWARD model.backward(dw, db) │
│ w ← w – η · ∂L/∂w │
└─────────────────────────────────────────────────────────┘
There is no .fit(). There is no hidden state. The user controls every step.
TrueML models are stateless with respect to data. They hold parameters (weights, bias) but never cache a training example. This means:
If you want to log gradients before the update, you print them. If you want to try a custom update rule, you write it yourself. The library does not abstract away what you need to see.
gen doctor1
pip install gen-cli
1
2
3
4
5
6
7
8
git clone https://github.com/iamprasadraju/gen-cli.git
cd gen-cli
# Install for usage
pip install -e .
# Install for development (includes tests, linting tools)
pip install -e .[dev]
1
uv sync
1
gen --version
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Generate a C boilerplate file
gen c
# Generate a Python boilerplate file
gen py
# Generate a Flask project
gen flask
# List available languages and frameworks
gen list
# Show directory tree
gen tree
# Check your environment
gen doctor
gen --version)?Show the installed version of gen-cli.
1
2
gen --version
gen -v
Output: gen-cli version 1.0.0
gen --help)?Show the help message with all available commands and options.
1
2
gen --help
gen -h
gen list)?List all available language templates and framework templates.
1
gen list
Output:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Available Languages
-------------------
• .py
• .c
• .cpp
• .go
• .js
• .rs
• .html
• .java
Available Frameworks
--------------------
• flask
• codeforces
gen doctor)?Check your environment and configuration for potential issues.
1
gen doctor
Output:
1
2
3
4
5
6
7
8
Gen CLI Doctor
----------------------------------------
✓ Python Version: 3.13.12
✓ Platform: Darwin 24.0.0
✓ Working Directory: /Users/user/project
✓ PATH directories: 17 found
All checks passed
gen tree)?Display a colorful tree view of your directory structure.
1
2
3
4
5
gen tree # current directory, depth 2, no hidden
gen tree -a # include hidden files/dirs
gen tree -3 # depth of 3 levels
gen tree -3 src # depth 3 of specific directory
gen tree -2 -a . # depth 2, include hidden, current dir
Tree options:
| Flag | Description |
|---|---|
-N |
Set depth (e.g., -2, -3) |
-a, --all |
Include hidden files/dirs |
Colors:
Generate a boilerplate file for a specific language.
1
2
3
4
5
6
7
8
gen c # creates main.c
gen py # creates main.py
gen js # creates main.js
gen go # creates main.go
gen rs # creates main.rs
gen cpp # creates main.cpp
gen java # creates main.java
gen html # creates main.html
Options:
| Flag | Description |
|---|---|
--dryrun |
Preview the file content without creating it |
--overwrite |
Overwrite existing file |
Examples:
1
2
3
gen c --dryrun # preview main.c content
gen py --overwrite # overwrite main.py if exists
gen js --dryrun --overwrite # dry run (overwrite ignored)
When file already exists:
1
2
3
gen c
main.c already exists
Use --overwrite to replace: gen c --overwrite
Generate a full project from a framework template.
1
2
3
4
gen flask # prompts for project name
gen flask myapp # creates myapp/ directly
gen codeforces # prompts for project name
gen codeforces solutions # creates solutions/ directly
Options:
| Flag | Description |
|---|---|
--dryrun |
Preview project structure without creating |
--overwrite |
Remove existing directory and regenerate |
Examples:
1
2
3
gen flask --dryrun # preview flask project tree
gen flask myapp --dryrun # preview tree for 'myapp'
gen flask myapp --overwrite # overwrite myapp/ if exists
When directory already exists:
1
2
3
gen flask myapp
Directory 'myapp' already exists
Use --overwrite to replace: gen flask myapp --overwrite
| Command | Output File |
|---|---|
gen c |
main.c |
gen py |
main.py |
gen js |
main.js |
gen go |
main.go |
gen rs |
main.rs |
gen cpp |
main.cpp |
gen java |
main.java |
gen html |
main.html |
| Command | Description |
|---|---|
gen flask |
Flask web application |
gen codeforces |
Codeforces competitive programming setup |
Gen-CLI provides clear error messages for common issues:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Unknown command
gen xyz
→ Unknown command: xyz
Usage: gen [list|doctor|tree|<lang>|<framework>] [-v|--version] [-h|--help]
# Unknown flag
gen c --invalid
→ Unknown flag: --invalid
Usage: gen [list|doctor|<lang>|<framework>] [-v|--version] [-h|--help]
# Invalid tree depth format
gen tree 3
→ Invalid depth format: '3'
Use '-' prefix for depth, e.g., 'gen tree -3' or 'gen tree -3 src'
# Path not found
gen tree nonexistent
→ Path not found: nonexistent
1
uv sync --all-extras
1
2
3
4
5
# Run all tests
uv run pytest tests -v
# Run specific test file
uv run pytest tests/test_cli.py -v
1
uv run gen <command>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
gen-cli/
├── src/
│ └── gen/
│ ├── __init__.py
│ ├── cli.py # Main CLI entry point
│ ├── paths.py # Template path resolution
│ ├── commands/
│ │ ├── __init__.py
│ │ ├── doctor.py # Environment diagnostics
│ │ ├── helper.py # Help messages
│ │ ├── list_.py # Template listing & tree view
│ │ └── template.py # Template generation helpers
│ ├── core/
│ │ ├── __init__.py
│ │ └── render.py # Jinja2 template rendering
│ └── templates/ # Built-in templates
│ ├── lang/ # Language boilerplate files
│ └── frameworks/ # Framework project templates
├── tests/
│ └── test_*.py # Unit tests
├── pyproject.toml
└── README.md
MIT License
Prasad Raju G
]]>
A graphical Tic-Tac-Toe game built with Python and Pygame, featuring a pixel-art aesthetic and a classic two-player experience.
1
pip install -r requirements.txt
Or with uv:
1
uv sync
1
python game.py
1
2
3
4
5
6
7
8
9
├── game.py — Entry point and main game loop
├── board.py — Game board, grid rendering, move logic, win/draw detection
├── effects.py — Confetti particle system for win celebrations
├── assets/ — Fonts and images
│ ├── PixeloidSans.ttf
│ ├── PixeloidSans-Bold.ttf
│ └── tic-tac-toe.png
├── requirements.txt — Runtime dependency (pygame)
└── pyproject.toml — Project metadata and Python version