Generate custom gridfinity bins from photos of your tools.

1. Place tools on A4/Letter paper (tools can overflow the edges)
2. Take a photo from above
3. Upload and adjust paper corners for scale calibration
4. AI traces tool outlines automatically
5. Save traced tools to your library
6. Group tools into projects when planning a drawer or workspace
7. Create bins from project tools, arrange the layout
8. Download STL/3MF for 3D printing

Dashboard	Tool Editor	Bin Editor

Try it at tracefinity.net without installing anything, or self-host:

# local model (no API key needed)
docker run -p 3000:3000 -v ./data:/app/storage ghcr.io/tracefinity/tracefinity

# or with Gemini API
docker run -p 3000:3000 -v ./data:/app/storage -e GOOGLE_API_KEY=your-key ghcr.io/tracefinity/tracefinity

# remote saliency via fal.ai
docker run -p 3000:3000 -v ./data:/app/storage -e FAL_KEY=your-key ghcr.io/tracefinity/tracefinity

# remote saliency via Replicate
docker run -p 3000:3000 -v ./data:/app/storage -e REPLICATE_API_TOKEN=your-token ghcr.io/tracefinity/tracefinity

# run as your host user (files in ./data owned by you, not root)
docker run -p 3000:3000 -v ./data:/app/storage --user "$(id -u):$(id -g)" ghcr.io/tracefinity/tracefinity

With a remote provider the corrected paper crop is sent to that provider for masking. fal is called with sync_mode, so the result is not kept in request history; Replicate API predictions (including the input image) auto-purge after about an hour, which is the only retention control Replicate exposes (it has no API to delete them sooner).

Open http://localhost:3000

By default, Tracefinity uses IS-Net for local tracing -- no API key needed. Set GOOGLE_API_KEY to use Gemini instead. See Tracing Modes for RAM requirements per model.

Prerequisites: Python 3.11+, Node.js 20+, pnpm

git clone https://github.com/tracefinity/tracefinity
cd tracefinity

# First time setup
cd backend && python3 -m venv venv && source venv/bin/activate && pip install -r requirements.txt
cd ../frontend && pnpm install
cd ..

# Run (starts backend on :8000 and frontend on :4001)
make dev

Open http://localhost:4001

Tracefinity supports three ways to trace tool outlines from photos. All three produce the same output -- black and white mask images that get converted to editable polygons via OpenCV contour extraction.

When no API key is configured, Tracefinity runs a local salient object detection model. No API key, no network access, no cost. Model weights download automatically on first trace. Three CPU-friendly models are available by default, selectable via the TRACERS env var or the UI dropdown:

Paper corner detection runs U2-Net Portable alongside the tracer. RAM figures include both models. All models load at startup.

Minimum RAM: 2GB (IS-Net). BiRefNet Lite needs 8GB.

BiRefNet General is available as an opt-in GPU tracer. For NVIDIA GPU tracing from source, install the optional GPU requirements after the default backend requirements, set TRACERS=birefnet-general,birefnet-lite,isnet, and set TRACEFINITY_ONNX_PROVIDER=cuda to require CUDA:

pip install -r backend/requirements.txt -r backend/requirements-gpu.txt

This uses ONNX Runtime GPU for the rembg models (isnet, birefnet-lite, birefnet-general) and avoids PyTorch CUDA for those tracers.

See #21 for the benchmark that led to this selection.

Set GOOGLE_API_KEY to use Google's Gemini models instead. Higher accuracy overall, especially on complex or reflective tools. To get a key: Google AI Studio (free tier available).

No API key and prefer not to use the local model? Upload a mask manually:

1. Upload your photo and set paper corners
2. Click "Manual" and download the corrected image
3. Open Gemini and paste the image with the provided prompt
4. Download the generated mask (black tools on white background)
5. Upload the mask back to Tracefinity

• AI-powered tracing -- Local model or Gemini generates accurate tool silhouettes from photos
• Manual mask upload -- Use the Gemini web interface without an API key
• Selective saving -- Choose which traced outlines to keep before saving to your library
• Tool library -- Save traced tools and reuse them across multiple bins
• Bin projects -- Plan a group of tools and bins together, track which tools still need bins, and create project-scoped bins
• Tool editor -- Rotate tools, add/remove vertices, adjust outlines, snap to grid
• Smooth or accurate -- Toggle Chaikin subdivision for smooth curves, or keep the raw trace; SVG and STL exports both respect this
• Finger holes -- Circular, square, or rectangular cutouts for easy tool removal
• Interior rings -- Hollow tools (e.g. spanners) traced correctly with holes preserved
• Bin builder -- Drag and arrange tools with snap-to-grid, auto-sizing to fit the gridfinity grid
• Cutout clearance -- Configurable tolerance so tools fit without being too loose
• Cutout chamfer -- Bevelled top edges on tool pockets for easy tool insertion
• Contrast insert -- Generate a separate STL for printing tool silhouettes in a different colour
• Text labels -- Recessed or embossed text on bins
• Gridfinity compatible -- Proper base profile, magnet holes, stacking lip
• Live 3D preview -- See your bin in three.js before printing
• STL and 3MF export -- 3MF supports multi-colour printing for embossed text
• SVG export -- Individual tool outlines as SVG, with smoothing applied
• Bed splitting -- Large bins auto-split into printable pieces with diagonal fit detection
• Landscape and portrait -- Paper orientation auto-detected from corner positions
• Single-container Docker -- Frontend and backend in one image, data in a single volume

Step-by-step usage guides covering each part of the workflow:

• Getting started
• Uploading photos
• Tracing
• Tool editor
• Tool library
• Bin configuration
• Bin layout
• Projects
• Exporting
• Keyboard shortcuts

Gridfinity is a modular storage system designed by Zack Freedman. Bins snap into baseplates on a 42mm grid, making it easy to organise tools, components, and supplies. The system is open source and hugely popular in the 3D printing community.

MIT