Reflex++

Rapid Development, Native Performance

Modern Design

Reflex++ introduces a first-class Object model with a dynamic property system, purpose-built for rapid development and modern UI workflows.

Properties are data-driven, introspectable, serializable, and integrate seamlessly with structured formats like JSON.

This unlocks the speed and flexibility developers expect from web and dynamic languages, yet with native performance, fast compile times and tiny binaries.

Without Compromise

All high-level features are in turn built on lower level API’s and primitives, including platform abstractions, SIMD operations, GPU rendering, and low-latency audio.

Reflex++ delivers a single, coherent native stack, combining the productivity of modern frameworks with the flexibility and performance of traditional C++ development.

No Webviews

Reflex features a complete GPU-powered UI, with powerful layout model, stylesheets and hot reloading. Everything good about HTML/CSS/JS webviews without the legacy, bloat and having to manage two sets of state.

Live Styling

Hot reloading of stylesheets. No need to recompile to view changes and iterate. See your UI updates instantly while maintaining native C++ performance.

Cross-Platform

Write once, deploy everywhere. Build native applications for Windows, macOS, iOS, and Android from a single codebase without compromising on platform-specific performance.

Native Performance

Zero runtime overhead. Your UI code compiles to native machine code, delivering the raw performance that C++ developers expect. No interpreters, no virtual machines, means straightforward debugging and best in class performance.

Built to Scale

Move fast solo, or scale up without chaos.

Modular

Reflex++ is organised as a layered collection of focused C++ modules, with intuitive namespaces and consistent APIs that make the framework straightforward to navigate and extend.

The modular architecture and strong separation of concerns allow individuals and teams to work efficiently, from small tools and plugins to large-scale applications and codebases.

Flexible

Use the full Reflex++ stack, or adopt only the modules you need.

While typically used as a complete native application framework, Reflex++ can also be integrated selectively alongside existing engines, frameworks, and build systems.

See our JUCE integration tutorial for a practical example of embedding Reflex GLX into an existing JUCE application.

Bootstrap

Application startup and framework entry scaffolding.

App launch helpers and entrypoint setup

Project bootstrapping for different app types

Shared initialization utilities for consistent startup

Code Examples

Reflex++ combines declarative data and styling with powerful C++ APIs.

Explore real examples from across the framework.

include: "common.glx";

size: 512,384;

bg_color: 40,41,42;

Display:
{
   render: x4;               //4x antialiasing
   
   @Float32 line_width: 2;   //custom property used by eq_curve
   
   bg: 
   Gradient(angle: 0.25; from: 64; to: 32; dither: 16),
   Blur(radius: 16; opacity: 0.5; content: Canvas(id: eq_curve)),
   Canvas(id: eq_curve),
   InnerShadow(width: 4,0; color: 0,0,0,32);
};

@Color outline: 160,160,160;   //define a constant

Control:
{
   margin: 20,10;
   padding: 0,0,20,0;

   bg: Text(font: Medium; value: &value; justify: bottom; color: 172);
   
   common:
   {
      render: x4;
      size: 64;
      color: outline;
   };

   continuous:
   {
      inherit: common;

      sweep_range: 0.375,0.75;
                  
      bg:
      Rotate
      (
         angle: &indicator;  // & creates a live binding to a named property, set from C++
         content:
         Align
         (
            position: right;
            size: 12,2;
            content: Fill(corner: 0.75)
         )
      ),
      Circle(sweep: 0.375,0.75; width: 2);
      
      @State hover:
      {
         transition: 0.25;
         color: 220;
      };
   };

   boolean:
   {
      inherit: common;

      bg: Border(indent: 12,0; corner: 8; width: 2);
   };
   
   enumeration: { inherit: boolean; }; 
};

ViewImpl::ViewImpl(Instance & instance)
   : View(instance, kChunkVersion, L":res:Demo/styles.glx")
   , instance(instance)
{
   // add parameter controls
   auto num_param = instance.GetNumParameter();
   for (UInt idx = 0; idx < num_param; ++idx)
   {
      GLX::AddInline(m_controls, New<Bootstrap::ParamControl>(instance, idx));   //ParamControl provides out-of-box parameter controls
   }

   GLX::AddInline(*this, m_controls, GLX::kOrientationCenter);


   //add GPU rendered EQ display with custom drawing, see Canvas(id: eq_curve) in stylesheet	
   GLX::SetCanvas(m_eq_display, "eq_curve", [this](GLX::CanvasContext & ctx)
   {
      //prepare GPU vertex data for the EQ curve

      GLX::Points path(96);

      for (UInt idx = 0; idx < 96; ++idx)
      {
         auto x = Float(idx) / 95.0f;
         path[idx] = MakePoint(x, 1.0f - EvaluateEQ(x)) * ctx.size;
      }

      GLX::AddPath(ctx.output, path, false, m_eq_line_width, GLX::kPathJoinRound, GLX::kPathCapSquare);   //not closed
   });

   GLX::AddInlineFlex(*this, m_eq_display); 
}

void ViewImpl::OnSetStyle(const GLX::Style & style)
{
   auto control_style = style["Control"];
   for (auto & i : m_controls) i.SetStyle(control_style);

   m_eq_line_width = Data::GetFloat32(style, "line_width", 2.0f);
   
   m_eq_display.SetStyle(style["Display"]);
}

void ViewImpl::OnUpdate()
{
   // engine state changed — ParamControls update automatically
   // recalculate EQ coefficients here, call Redraw to schedule the eq_curve canvas lambda
   m_eq_display.Redraw();
}

// Data::Serialize appends raw bytes to byte-array
void AppImpl::OnStore(Data::Archive& stream) const
{
	Data::Serialize(stream, m_notes.GetSize());

	for (auto& note : m_notes)
	{
		Data::Serialize(stream, note.title, note.body, note.created);
	}
}

// Data::Deserialize advances the byte-view
void AppImpl::OnRestore(Data::Archive::View& stream, Key32 context)
{
	m_notes.SetSize(Data::Deserialize<UInt32>(stream));

	for (auto& note : m_notes)
	{
		Data::Deserialize(stream, note.title, note.body, note.created);
	}
}

// OnImport is called when loading older chunk versions
bool AppImpl::OnImport(UInt16 version, Data::Archive::View& stream, Key32 context)
{
	return false;
}

// Export to JSON
void AppImpl::Export(const WString& path)
{
	// PropertySet keys are compile-time hashed 32-bit integers
	Data::PropertySet json;

	auto keymap = Data::AcquireKeyMap(json);

	auto title_key = Data::RegisterKey(keymap, "title");
	auto body_key = Data::RegisterKey(keymap, "body");
	auto created_key = Data::RegisterKey(keymap, "created");

	auto notes_array = Data::AcquirePropertySetArray(json, Data::RegisterKey(keymap, "notes"));

	for (auto& note : m_notes)
	{
		auto note_node = Data::AddPropertySet(notes_array);

		Data::SetCString(note_node, title_key, note.title);
		Data::SetCString(note_node, body_key, note.body);
		Data::SetInt64(note_node, created_key, note.created);
	}

	File::Save(Data::EncodePropertySet(Data::kJsonFormat, json), path);
}

// Import from JSON
void AppImpl::Import(const WString& path)
{
	auto json = Data::DecodePropertySet(Data::kJsonFormat, File::Open(path));

	// safe to iterate even if missing
	auto notes_array = Data::GetPropertySetArray(json, "notes");

	m_notes.Clear();

	for (auto& i : notes_array)
	{
		auto& note_node = *i;

		auto& note = m_notes.Push();

		// safe default/null fallback, no cast checks required
		note.title = Data::GetCString(note_node, "title");
		note.body = Data::GetCString(note_node, "body");
		note.created = Data::GetInt64(note_node, "created");
	}

	Notify(false);	// publish state change
}

// ViewImpl inherits Bootstrap::Streamable to attach an independent persistence chunk
// view state is only processed when the view is instantiated

void ViewImpl::OnStoreState(Data::Archive& stream) const
{
	Data::Serialize(stream, m_selection, m_body.GetSplitSize(m_left));
}

void ViewImpl::OnRestoreState(Data::Archive::View& stream, Key32 context)
{
	Data::Deserialize(stream, m_selection);

	m_body.SetSplitSize(m_left, Data::Deserialize<Float32>(stream));
}

bool ViewImpl::OnImportState(UInt16 version, Data::Archive::View& stream, Key32 context)
{
	return false;
}

// Async::Worker runs on a background thread
auto task = New<Async::Worker>([](Async::Worker::Context& ctx)
{
    auto bands = New<Allocation<Float32>>(kNumBands);

    for (UInt i = 0; i < kNumBands; ++i)
    {
        // check for cancellation each iteration — eg. if view was destroyed or task replaced
        if (ctx.Cancelled())
        {
            ctx.SetResult(false);
            return;
        }

        bands[i] = AnalyseBand(i);  // heavy per-band work here
    }

    ctx.SetResult(true, bands);
});

// AttachAwait binds the task to its owner as a named property —
// if the owner is destroyed before completion, the callback is never called
Async::AttachAwait(*this, "analyse", task, [this](bool ok, Reflex::Object& result)
{
    if (ok)
    {
        auto bands = Cast<Allocation<Float32>>(result);
        m_display.SetProperty("bands", bands);  // pass result to display via property — canvas lambda reads it on redraw
        m_display.Redraw();
    }
});

// Async::CreateHttpRequest is a high-level HTTP wrapper, includes automatic support for receiving content-type/JSON
auto task = Async::CreateHttpRequest("GET", "https://api.example.com/version", {}, {});

Async::AttachAwait(*this, "version_check", task, [this](bool ok, Reflex::Object& result)
{
    if (!ok) return;

    // DynamicCast checks the Object type
    if (auto json = DynamicCast<Data::PropertySet>(result))
    {
        auto latest  = Data::GetCString(*json, "version");
        auto message = Data::GetCString(*json, "message");

        if (latest != kAppVersion)
        {
            GLX::SetText(m_update_label, ToWString(message));
        }
    }
});

Desktop, Mobile, Pro-Audio and Beyond...

Reflex++ is built to deliver cross-platform software with real-time responsiveness, high-performance execution, and rich GPU-accelerated UIs.

With built-in low-latency audio support and first-class plugin integration, Reflex++ is a natural fit for pro-audio development.

Desktop

Build powerful desktop applications for macOS and Windows.

macOS

Windows

Mobile

Create native mobile experiences for iOS and Android.

iOS

Android

Pro-Audio

Low-latency audio engines and plugin development.

VST3

Audio Units

AUv3

CLAP

CLI / Tooling

Command line tools, build systems and automation.

Linux

Windows

macOS

Comparison Matrix

We built Reflex++ to be the most lightweight, high-performance cross-platform C++ framework available.

Reflex++

QtQuick

JUCE

Flutter

Cross-platform

✓

No external dependencies

✓

Single native stack

✓

Native GPU UI Pipeline

✓

Built in Live Edit / Hot Reload

✓

Native Audio Plugin support

✓

Hello World app size (rel/win64)

~2.5mb

~25mb

~3mb

~25mb

Start building with Reflex++

Modern apps in C++ are just a few clicks away...

Get Started

Documentation

Pricing

Modern App Development in C++ Build GPU-accelerated, high-performance cross-platform apps with Reflex++