sagebox 0.1.1

A High-Performance, Procedural GUI Designed for Rapid, Creative Development

Sagebox is a set of GUI tools that let you add windows, graphic controls, and graphical output to your Rust programs using linear, procedural code, without any boilerplate, or the overhead of an event-driven framework.

As a persistent (i.e. retained — but with no need to redraw) set of GUI tools, Sagebox was built from scratch as a platform-agnostic, comprehensive GUI — supporting everything from high-performance, cross-platform applications, fun-with-graphics programs, and console-mode-only projects using GUI controls for development or release.

Sagebox drops cleanly into existing code or new projects when rapidly prototyping or exploring creative ideas.

Tools and Controls in Sagebox start simple and can scale as you want to do more. Additional options for more complexity can be added in as needed through the use of keywords in the function call.

Sagebox manages its own environment, so you don't have to keep track of any of the controls or widgets that are launched, unless you want to.

Features

• Procedural, linear programming style
• No macros or boilerplate
• Console-mode support with add-on GUI-Control integration
• Compatible with other GUI libraries
• Accepts all Rust native types for all functions
• Designed to stay out of the way of your code

note: This initial beta is released as the Windows version to showcase Sagebox’s core architecture ahead of the Linux release and gather community feedback. See Sagebox Roadmap and About This Release for details.

Click here to see examples on Youtube • Github project: https://github.com/Sagebox/Sagebox-rs

Entire Program Example

use sagebox::*;

fn main() {
    let win = Sagebox::new_window();
    win.draw_circle((200,150), 100, "green"); 
    win.wait_for_close();     // Wait for user to close window               
}

Controls Without a Window — Program Example

use sagebox::*;

fn main() {
    let my_slider = Sagebox::dev_slider("This is my slider");

    // One of several ways to process events procedurally:

    while Sagebox::wait_event() {   
        if my_slider.moved() { 
            println!("Slider value = {}",my_slider.get_pos()); 
        }
    } // loop exits when user closes the Dev Window
}

Simple and Powerful

By adding just a few more lines of code, more tools can be created.

The above examples show using Sagebox functions as easy library calls, from basic controls (left), to graphics with and without controls (right) – all with just simple function calls without event-driven or GUI programming, representing a small amount of the overall code that stays out of the way and doesn't require any programming or GUI environment.

The middle image, for example, is a one-line function call:

Sagebox::image_view_before_after(&image1,&image2);

This can be called as a single function call, with no prior Sagebox initalization. Keyword elements can be added to extend its functionality, and the returned object can be kept by the program to manage the new window, or simply discarded to let Sagebox manage it on your program's behalf while the code continues on.

Using Sagebox in Console Mode

Sagebox can be used for traditional graphics programs with pure graphics and GUI-based controls — or pure Console-Mode applications.

In Console Mode, you can use Sagebox functions to help with the program user-interface, such as simple sliders, buttons, or other controls. You can also bring up entry boxes, quick dialogs, before & after graphics windows, color selectors, or other widgets.

Because these are just simple function calls, you can put them into your existing code without changing your structure or interfering with the rest of your code.

Sagebox requires no program initialization, so you can just drop in any GUI control or other Sagebox function anyhwere and it will work.

Even if your end-product code doesn’t use any GUI-based graphic controls, Sagebox can still be useful during development, helping with user input and visualizing program flow while you’re developing and debugging.

Examples with Source Code, Screenshots, and Videos

Below are some of the examples included in the Github main page.

These range from simple Hello World programs demonstrating handling events, to pure graphics programs, and medium and realtime large-scale programs as examples of personal, fun-with graphics, educational/research, or industry-related use.

Sagebox has been used professionally in the tech industry by companies like Pentair and Pioneer, and most recently in the semiconductor field at ASML, where it was called “that magic program.”

click on the example project names to go directly to the project directory with example code and screenshots.

Support Active Development

Sagebox is actively developed and welcomes early support from developers and contributors.

Sagebox was developed as a powerful and comprehensive GUI that is also very easy to use. It is free to use in personal and commercial Rust projects. Contributions keep it free and also keep it growing. (See Sagebox Roadmap)

🌱 Sponsor Sagebox on Github

Your support helps add new features, documentation, and to continue to provide Sagebox free to the Rust community.

See more examples and documentation visit:
https://github.com/Sagebox/Sagebox-rs