Futureboard Update: Windows Developer Preview

Futureboard Studio is entering its first Windows Developer Preview phase.

This is an early technical release focused on validating the native Windows build of Futureboard Studio before the wider Alpha channel. It is not a production-ready release yet, and it is not intended for daily music production work at this stage.

The goal of this preview is to test the foundation: the application shell, audio playback, project workflow, plugin hosting, UI behavior, packaging, and the early architecture that will carry Futureboard forward.

What This Preview Is

The Windows Developer Preview is a technical preview for developers, contributors, early testers, and users who want to follow the development of Futureboard Studio closely.

This build is focused on real-world testing of the native Windows version. Some features are incomplete, some workflows may change, and some parts of the application may still be unstable. Crashes, missing UI polish, plugin compatibility issues, and project format changes are still expected during this phase.

This preview exists so we can test the core system earlier, find problems faster, and improve the application before the public Alpha release.

Why Windows First

Futureboard Studio is currently focused on Windows first because Windows is still one of the most important platforms for music production, plugin development, and audio hardware support.

It is also one of the hardest platforms to get right.

Plugin hosting, audio drivers, HiDPI behavior, external editor windows, device compatibility, and low-latency audio paths all require careful testing on real systems. Starting with Windows allows us to solve these difficult problems early and build a stronger foundation for the rest of the platform work.

macOS and Linux support are still part of the long-term plan, but the current Developer Preview is focused on Windows.

Audio Backend

The Windows Developer Preview currently uses WASAPI as the primary audio backend.

For this phase, the focus is on making playback, device selection, buffer handling, and general audio stability reliable across normal Windows systems. WASAPI gives us a practical and widely available base for testing the current audio engine without requiring custom drivers or vendor-specific setup.

This preview is not yet using DAUx as the default audio backend.

DAUx is still under active research and development. It remains part of Futureboard’s long-term direction for native low-latency Windows audio, but in this preview it is treated as an experimental development track rather than the main production audio path.

The current priority is stability first: make the application play audio reliably, handle devices correctly, and provide a consistent base for future backend work.

Current Focus Areas

This Developer Preview focuses on the foundation of Futureboard Studio:

- Native Windows application shell

- GPUI-based interface and workspace layout

- Project creation, opening, and saving

- WASAPI audio playback and device handling

- Transport controls and timeline behavior

- Mixer layout and early routing workflows

- VST3 plugin scanning and loading

- Instrument and effect plugin separation

- External plugin editor window behavior

- Early multi-output plugin routing

- Application packaging and installer preparation

- Crash detection and development diagnostics

- Early DAUx backend research

The goal is not to ship every planned DAW feature immediately. The goal is to make sure the foundation is strong enough before building more complex workflows on top of it.

Plugin Hosting Progress

VST3 plugin hosting is one of the biggest areas of work in this preview.

The current build includes plugin scanning, plugin loading, instrument/effect separation, and early routing support. Some plugins already work, while others still expose difficult issues around editor windows, custom UI frameworks, WebView-based interfaces, Qt/QML-based plugins, HiDPI behavior, and external process hosting.

This is expected at this stage.

Plugin hosting is one of the hardest parts of building a DAW. Every plugin vendor makes different assumptions about windows, threading, focus, rendering, scaling, and host behavior. Testing these cases early is important so Futureboard can become more compatible and reliable over time.

The Developer Preview is the first step toward that process.

Multi-Output Routing

Futureboard is also testing early multi-output plugin routing.

This is especially important for drum instruments, samplers, and complex virtual instruments that expose multiple mono or stereo outputs. The current work focuses on detecting plugin bus layouts, mapping outputs into the mixer, and preparing the routing system for more flexible workflows later.

This system is still being refined. Some plugins may expose unusual layouts, and some routing behavior may change before Alpha.

DAUx Direction

Futureboard is continuing research and early implementation work on DAUx, our long-term low-latency native audio direction for Windows.

In the current Windows Developer Preview, WASAPI remains the main audio backend. DAUx is not enabled as the default backend yet.

The current DAUx work is focused on validating the architecture, driver communication model, SDK direction, device discovery, and future integration path. It is being developed carefully because audio drivers and low-latency systems need to be stable, predictable, and safe before they become part of the normal user-facing workflow.

Long-term, DAUx is intended to become a modern native audio system for low-latency Windows workflows. It is part of Futureboard’s larger goal of building an open, high-performance audio platform beyond the limitations of existing driver models.

But for this preview, WASAPI is the stable baseline.

User Interface Work

The Windows Developer Preview also includes the current native interface work for Futureboard Studio.

The UI is still evolving, but the main direction is clear: a compact, modern, performance-focused DAW interface designed for long sessions, dense projects, and fast editing.

Current work includes:

- Timeline layout

- Mixer structure

- Track controls

- Transport bar

- Plugin panels

- Project navigation

- Native window behavior

- Theme and visual polish

- HiDPI handling

Some parts of the interface are still unfinished or temporary. The Developer Preview will help identify which workflows need more polish before the Alpha release.

Known Limitations

This preview is still early and has known limitations.

Current limitations may include:

- Some VST3 plugins may fail to load

- Some plugin editor windows may hang or appear incorrectly

- HiDPI scaling may not be correct for every plugin

- WebView-based plugin interfaces may require additional handling

- Qt/QML-based plugin editors may still expose compatibility problems

- Multi-output routing is still experimental

- Automation UI is incomplete

- Some mixer and timeline workflows are unfinished

- Audio behavior may vary depending on the device

- Project compatibility may change before Alpha

- Installer behavior is still being finalized

- Some crashes are still expected during testing

Please do not use this build for production sessions yet.

If you test this preview, use backup projects, test files, and non-critical sessions.

What We Want To Learn

The Developer Preview is mainly about learning from real systems.

We want to understand:

- Which audio devices work reliably with the current WASAPI backend

- Which plugins load correctly

- Which plugins fail, hang, or behave unexpectedly

- How plugin editor windows behave on different DPI settings

- How the application performs on different Windows machines

- Where the UI feels slow, unclear, or unfinished

- Which workflows break during normal testing

- What needs to be fixed before Alpha

This feedback will directly shape the next phase of Futureboard Studio.

What Comes Next

After the Windows Developer Preview, the next milestones are focused on stability and usability.

Planned work includes:

- Improving VST3 compatibility

- Strengthening plugin editor isolation

- Refining multi-output plugin routing

- Expanding automation support

- Improving the mixer and track workflow

- Improving project loading and recovery behavior

- Polishing the timeline and editing experience

- Strengthening WASAPI backend stability

- Continuing DAUx driver and SDK development

- Preparing the first public Alpha channel release

The Developer Preview is not the finish line. It is the point where the system becomes real enough to test seriously.

Release Status

The Windows Developer Preview is an early development build.

It should be treated as:

- Not production-ready

- Not feature-complete

- Not final UI

- Not final project format

- Not final plugin compatibility

- Not the final audio backend architecture

It is a preview for testing, feedback, and development validation.

Closing

The Windows Developer Preview is an important milestone for Futureboard Studio.

It marks the transition from internal experiments into broader technical testing. The application is still early, but the foundation is now strong enough to begin validating the real Windows build, the audio engine, the plugin host, and the direction of the platform.

Futureboard is being built as a native, open, modern DAW with a long-term focus on performance, flexibility, plugin compatibility, and low-latency audio workflows.

There is still a lot to build, fix, and refine, but this preview is the first real step toward the public Alpha.

Thank you to everyone following the project, testing early builds, reporting issues, and helping shape the future of Futureboard Studio.