Bezy is an in-development cross-platform font editor with a built-in bidirectional text editor and TUI/CLI-first workflow designed for AI collaboration and automation.

Drawing inspiration from customizable editors like RoboFont and MFEK, Bezy reimagines font editing for contemporary Unix-like AI and CLI heavy workflows. It features two core innovations: a multi-buffer text editor supporting both LTR and RTL scripts, and a Terminal User Interface (TUI) that runs alongside the GUI for command-line automation. The core dependencies are: Bevy, HarfRust, Norad, Kurbo, and Fontc.

Bezy is written in the Rust programming language using a game engine to create a performant and fun experience that keeps users in a flow state. It is designed to be a visually pleasing environment where design work is done, not just a non-aesthetic production tool.

Rust has great documentation, a friendly compiler with useful error messages, top-notch tooling, and an integrated package manager and build tool. With help from AI tools like Claude Code and Gemini CLI, it can be easier to use than Python. Don't be intimidated if you are not an expert programmer—this application is designed for students, designers, and artists to be able to customize it and make their own tools and other additions.

The project aims to be a welcoming community that values working in the open, sharing knowledge, and helping people become better programmers. Contributors of all skill levels are welcome.

“The enjoyment of one's tools is an essential ingredient of successful work.”
—Donald Knuth

“Many have tried to replace FontForge—all have failed. I might fail, in fact, history says I probably will. Yet, the current state of affairs is so bad I feel I must try.” —Fredrick Brennan

• Rust 1.90.0 or later - Install Rust by following the official instructions at rust-lang.org.

cargo --version
rustc --version  # Should be 1.90.0 or later

git clone https://github.com/bezy-org/bezy.git
cd bezy

# Build and run
cargo run

# Build with optimizations (slower to compile, faster to run)
cargo run --release

# Build and run with a specific font source (UFO or designspace)
cargo run -- --edit path/to/your/font.ufo

Bezy supports several build configurations for different use cases:

# Default build with TUI enabled
cargo build

# Optimized release build
cargo build --release

For faster compile times during development, use the dev feature which enables dynamic linking:

# Development build with fast recompilation
cargo build --features dev
cargo run --features dev

This significantly speeds up incremental builds when making frequent changes to the code.

To build without TUI support:

# Build without Terminal User Interface
cargo build --no-default-features

# Run GUI-only version
cargo run --no-default-features -- --edit MyFont.ufo

Note: The tui feature is enabled by default. Disabling it removes the Ratatui and Crossterm dependencies.

You can install Bezy globally and use it as a command-line tool from anywhere on your system.

# From within the bezy directory after cloning
cargo install --path .

# Or install directly from GitHub
cargo install --git https://github.com/bezy-org/bezy.git

Once installed, you can run Bezy from anywhere on your system.

# Launch the editor without loading a source file 
bezy

# Check the version
bezy --version

# Check the installation location
which bezy

To update after making changes or pulling new updates:

# If you're working from the cloned repository
cd path/to/bezy
git pull
cargo install --path .

# Or reinstall directly from GitHub
cargo install --git https://github.com/bezy-org/bezy.git

# If you are having trouble updating try with --force
cargo install --path . --force

# To remove the globally installed version
cargo uninstall bezy

# Edit a specific font source (UFO or designspace)
bezy --edit ~/Fonts/MyFont.ufo

The --edit flag intelligently handles both UFO directories and designspace files:

• Single UFO: Shows a clean interface without master selection controls
• Designspace: Shows master selector circles for switching between different masters

Bezy is designed to be used as a command line tool in Unix-style workflows.

# Initialize user configuration (run once)
bezy --new-config

# Edit a single UFO
bezy --edit ~/Fonts/MyFont.ufo

# Edit a designspace for variable fonts
bezy --edit ~/Fonts/MyVariable.designspace

# Use the strawberry theme
bezy --theme strawberry

# Combine as many flags as you need
bezy --edit ~/Fonts/MyFont.ufo --theme light

# Short form using -e
bezy -e MyFont.ufo

The edit-mode toolbar provides access to various editing tools. Each tool has specific behaviors:

• Selection Tool: Select and manipulate points
• Pen Tool: Add new points and contours
• Knife Tool: Cut contours at specific points
• Text Tool: A text editor built with editable type sorts
• Measure Tool: Measure distances between contours

Bezy runs with a Terminal User Interface (TUI) by default, providing a powerful command-line workflow alongside the GUI. The TUI appears in your terminal window and gives you access to multiple specialized tabs for different aspects of font editing.

The TUI provides 9 tabs:

• File - File operations, save actions, and current file path
• Edit - Edit mode controls and commands
• Unicode - Browse Unicode codepoints and glyphs
• Font Info - Font metadata and information
• QA - Quality assurance and validation tools
• Glyph - Glyph-specific information and editing
• Path - Path and contour information
• AI - AI-powered editing features
• Help - Keyboard shortcuts and help information

Navigate between tabs using the number keys or Tab/Shift+Tab.

If you prefer to run only the GUI without the TUI:

bezy --no-tui --edit MyFont.ufo

The TUI-first design makes Bezy ideal for:

• AI collaboration - Tools like Claude Code can interact with the TUI
• Automation - Script font editing workflows
• Remote work - SSH-friendly interface
• Log monitoring - Real-time log viewing without leaving the terminal
• Power users - Keyboard-driven workflows

Bezy uses a sophisticated logging system that keeps the TUI clean while providing detailed debugging information.

All application logs are automatically written to:

~/.config/bezy/logs/bezy-YYYY-MM-DD.log

Log files are rotated daily with the date in the filename.

Option 1: View in another terminal

# View logs in real-time
tail -f ~/.config/bezy/logs/bezy-$(date +%Y-%m-%d).log

# Or view today's log
tail -f ~/.config/bezy/logs/bezy-$(date +%Y-%m-%d).log

# Search for specific messages
grep "ERROR" ~/.config/bezy/logs/bezy-$(date +%Y-%m-%d).log

Option 2: Use the built-in TUI log viewer

• The TUI has a dedicated Logs tab for viewing application output
• Navigate to the Logs tab while the app is running

For development and debugging, you can disable the TUI to see logs directly in the terminal:

# Run with logs output to terminal
cargo run -- --no-tui --edit MyFont.ufo

The log directory is created automatically when you run:

bezy --new-config

This creates:

• ~/.config/bezy/logs/ - Directory for daily log files
• ~/.config/bezy/settings.json - User preferences
• ~/.config/bezy/themes/ - Editable theme files

Bezy includes four built-in themes and supports user configuration and theme customization.

• dark (default) - Dark background with light text
• light - Light background with dark text
• strawberry - Pink/red/green theme
• campfire - Warm orange/red/brown/black theme

You can set up a user configuration directory to customize settings and themes:

# Initialize your user config directory (run once)
bezy --new-config

This creates:

• ~/.config/bezy/settings.json - User preferences like default theme
• ~/.config/bezy/themes/ - Editable copies of all themes

After running --new-config, edit ~/.config/bezy/settings.json:

{
  "default_theme": "strawberry"
}

Now you can run bezy without the --theme flag and it will use your preferred theme.

Bezy uses this priority order for themes:

1. CLI argument: bezy --theme light (highest priority)
2. Config file: default_theme in ~/.config/bezy/settings.json
3. Built-in default: "dark" theme (fallback)

• Without user config: Uses embedded themes (no setup required)
• With ~/.config/bezy/themes/: Uses themes from this directory

# Initialize config to get editable theme files
bezy --new-config

# Now you can edit any theme file:
nano ~/.config/bezy/themes/strawberry.json

# Or create a new theme file:
cp ~/.config/bezy/themes/dark.json ~/.config/bezy/themes/mytheme.json
nano ~/.config/bezy/themes/mytheme.json

# Use your custom theme
bezy --theme mytheme

# Or set it as default in settings.json

When using custom themes from ~/.config/bezy/themes/, changes are reflected instantly when you save theme files (in debug builds).

• Limited to UFO format: Direct editing is only supported for UFO format. TTF/OTF files cannot be directly edited.
• Experimental AI features: AI-powered editing capabilities require additional setup and are still experimental.
• Advanced OpenType features: Some advanced OpenType features are not yet supported.
• Performance with large fonts: Performance optimization is needed for fonts with many glyphs (hundreds of glyphs may cause slowdowns).
• Glyphs.app compatibility: UFOs exported from Glyphs.app may have incompatible anchor formatting that can cause loading errors.

GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007

This project is licensed under the GNU General Public License (GPL), which means you are free to use, study, share, and change the software. The only condition is that if you share it with others—whether in its original form or with your own changes—you must also make the source code available under the same license. In short: the GPL ensures that the software (and any improvements to it) always stays free and open for everyone.

https://bezy.org