A native, high‑performance GLSL rendering engine written in Rust, designed for real‑time shader experimentation, MIDI control, and live video routing.

shadecore is a standalone OpenGL shader engine that renders a fullscreen GLSL fragment shader and publishes the output as a FBO texture or Syphon.

It is designed to be:

• fast enough for feedback systems,
• deterministic enough for installations,
• flexible enough to act as a base for many future tools.

There is no GUI framework, no WebView, and no runtime abstraction layer between your shader and the GPU.

This project exists to solve a common problem in creative coding:

“I want to build my own visual tools without shipping an entire framework.”

shadecore is intended to be:

• a foundation for custom shader‑based applications,
• a bridge between GLSL and external control systems,
• a standalone binary rather than a patch inside another tool.

• Native OpenGL rendering (via glow)
• Fullscreen GLSL fragment shader pipeline
• MIDI parameter control (CoreMIDI)
• JSON‑defined parameter schema
• Syphon server output (macOS)
• Vendored framework dependencies (no system installs)
• Deterministic build & runtime behavior

• macOS (Apple Silicon recommended)
• Rust (stable)
• Xcode Command Line Tools
• Syphon.framework (vendored in this repo)

cargo run

This will:

• compile the engine
• copy Syphon.framework next to the binary
• launch the renderer
• expose a Syphon server immediately

shadecore/
├─ src/
│  └─ main.rs              # Core engine loop
├─ native/
│  ├─ syphon_bridge.m      # Objective‑C Syphon bridge
│  └─ syphon_bridge.h
├─ vendor/
│  └─ Syphon.framework     # Vendored framework
├─ params.json             # Parameter & MIDI schema
├─ build.rs                # Framework linking + rpath logic
└─ Cargo.toml

• glow – OpenGL bindings
• winit / glutin – window + context
• midir – MIDI input
• serde / serde_json – parameter parsing

• OpenGL
• Cocoa / AppKit
• CoreMIDI
• Syphon (vendored)

• A window and OpenGL context are created using winit + glutin
• A fullscreen triangle is drawn every frame
• The fragment shader is responsible for all visual output

The engine provides:

• u_time – seconds since start
• u_resolution – window size in pixels
• user‑defined parameters (from JSON + MIDI)

• Rendering occurs into an offscreen framebuffer
• The framebuffer texture is:
  • drawn to the window
  • published to Syphon

• The OpenGL texture ID is passed to Syphon
• Other apps can receive frames in real time

Parameters are defined in a JSON file:

{
  "version": 1,
  "params": [
    {
      "name": "speed",
      "ty": "float",
      "min": 0.0,
      "max": 5.0,
      "default": 1.0,
      "midi_cc": 1
    }
  ]
}

• MIDI CC values (0–127) are normalized
• Values are scaled into parameter ranges
• Parameters are updated every frame

This makes controller layouts reproducible and portable.

• Live shader performance
• Visual instruments
• Generative art installations
• Feedback‑based video systems
• Custom tools for OBS / Resolume / TouchDesigner pipelines

• Hot‑loading shaders from disk
• Multi‑pass rendering / feedback buffers
• .app bundling
• Windows backend (Spout)
• OSC / network control

This tool is intentionally minimal and explicit.

Instead of abstracting creativity behind interfaces,
shadecore gives you direct control of the GPU and lets you decide what the software should become.

TBD