Skip to main content

​
Project Status

Lumix is currently in active development and is considered a work-in-progress showcase project. The codebase is evolving rapidly.
From the repository README:
This repository is intended to showcase progress, provide updates, and occasionally share work in progress versions of the project as it evolves. Pull requests or any sort of contribution isn’t accepted for the time being since the DAW is still barebone.
While direct contributions are not currently accepted, you can still:
  • Report bugs and issues
  • Suggest features and improvements
  • Build custom plugins for your own use
  • Fork and experiment with the codebase

​
Development Setup

​
Prerequisites

1

Install .NET SDK

.NET 6 SDK is required for compilation.Download from dotnet.microsoft.comVerify installation:
dotnet --version
2

Clone the Repository

git clone https://github.com/ImAxel0/Lumix.git
cd Lumix
For latest commits, check the Development branch.
3

Platform Configuration

Project must be compiled as x86 or x64.Configure in your IDE or via command line:
dotnet build -c Debug --arch x64
4

Debug Mode Setup

If compiling in debug mode, remove the LOCAL_DEV constant define from the .csproj file:
<!-- Remove or comment out this line -->
<DefineConstants>LOCAL_DEV</DefineConstants>

​
Building the Project

# Debug build
dotnet build -c Debug

# Release build
dotnet build -c Release

# Run the application
dotnet run --project Lumix
Expected Issues: Source is provided as-is. Expect crashes, unfinished features, and partially working functionality during development.

​
Development Environment

Visual Studio 2022

Full-featured IDE with excellent C# and .NET support
  • IntelliSense and debugging
  • Built-in Git integration
  • NuGet package management

Visual Studio Code

Lightweight editor with C# extension
  • Install C# Dev Kit extension
  • Integrated terminal
  • Git source control

JetBrains Rider

Cross-platform .NET IDE
  • Advanced refactoring tools
  • Excellent code analysis
  • Performance profiling

​
Required Extensions/Tools

  • C# Language Support - Syntax highlighting and IntelliSense
  • Git - Version control
  • NuGet - Package management (usually built into IDEs)

​
Codebase Structure

Understanding the project organization: 
Lumix/
├── Clips/                    # Timeline clip implementations
│   ├── AudioClips/          # Audio clip handling
│   ├── MidiClips/           # MIDI clip handling
│   └── Renderers/           # Visualization (waveforms, MIDI notes)
├── FileDialogs/              # OS file dialogs
├── ImGuiExtensions/          # Custom ImGui controls
├── Plugins/                  # Plugin system
│   ├── BuiltIn/             # Native C# plugins
│   │   ├── Eq/              # Equalizer plugin
│   │   └── Utilities/       # Utility plugin
│   └── VST/                 # VST2 host implementation
├── Resources/                # Icons and fonts
├── SampleProviders/          # NAudio audio pipeline
├── Tracks/                   # Track implementations
│   ├── AudioTracks/
│   ├── MidiTracks/
│   ├── GroupTracks/
│   └── Master/
├── Views/                    # UI components
│   ├── Arrangement/         # Main timeline view
│   ├── Midi/                # Piano roll editor
│   ├── Preferences/         # Settings UI
│   └── Sidebar/             # File browser
└── Program.cs                # Application entry point

​
Coding Standards

​
General Guidelines

Follow standard C# naming conventions:
// Classes and public members: PascalCase
public class AudioTrack
{
    public string Name { get; set; }
    public void StartRecording() { }
}

// Private fields: _camelCase with underscore
private string _name;
private bool _isPlaying;

// Local variables and parameters: camelCase
public void Process(float[] buffer, int sampleRate)
{
    int samplesRead = 0;
    float volume = 1.0f;
}

// Constants: PascalCase
public const int DefaultSampleRate = 44100;
  • One class per file
  • File name matches class name
  • Group related classes in folders
  • Use namespaces matching folder structure
// File: Tracks/AudioTracks/AudioTrack.cs
namespace Lumix.Tracks.AudioTracks;

public class AudioTrack : Track
{
    // Implementation
}
Document public APIs with XML comments:
/// <summary>
/// Processes audio through the plugin chain.
/// </summary>
/// <param name="input">The incoming unprocessed audio buffer</param>
/// <param name="output">The processed audio buffer</param>
/// <param name="samplesRead">Number of samples to process</param>
public void Process(float[] input, float[] output, int samplesRead)
{
    // Implementation
}

​
ImGui Usage Patterns

Lumix uses immediate-mode GUI with ImGui: 
public void Render()
{
    ImGui.Begin("Window Title");
    
    if (ImGui.Button("Click Me"))
    {
        // Handle button click
    }
    
    ImGui.SliderFloat("Volume", ref volume, 0f, 1f);
    
    ImGui.End();
}
Render methods are called every frame (~60 FPS). Avoid heavy computations in render methods.

​
Testing Your Changes

​
Manual Testing

Since Lumix is still in early development:
1

Build and Run

dotnet run --project Lumix
2

Test Core Functionality

  • Create audio and MIDI tracks
  • Load audio files and MIDI files
  • Add plugins to tracks
  • Test playback and recording
  • Verify UI interactions
3

Check for Crashes

Watch console output for exceptions and errors.

​
Common Issues

If using ASIO4ALL, the process may not close cleanly:
Program.cs
// Temporary workaround in Program.cs
Process.GetCurrentProcess().Kill();
VST plugins must be:
  • Valid VST2 format (not VST3)
  • Same architecture (x86/x64) as Lumix build
  • Located in configured plugin paths
Ensure graphics device is properly initialized:
  • Check Veldrid backend compatibility
  • Verify GPU drivers are up to date

​
Understanding the Audio Thread

Thread Safety: Audio processing runs on a separate thread. UI operations must not directly access audio buffers.
Audio flow: Key principles:
  1. No allocations in audio callbacks
  2. No locks that could block audio thread
  3. Pre-allocate buffers for audio processing
  4. Use lock-free patterns for thread communication

​
Plugin Development

For detailed plugin development guide, see Building Plugins. Quick start: 
public class MyCustomPlugin : BuiltInPlugin, IAudioProcessor
{
    public override string PluginName => "My Plugin";
    public bool Enabled { get; set; } = true;
    
    public void Process(float[] input, float[] output, int samplesRead)
    {
        // Process audio samples
        for (int i = 0; i < samplesRead; i++)
        {
            output[i] = input[i] * 0.5f; // Example: reduce volume
        }
    }
    
    public T? GetPlugin<T>() where T : class => null;
    public bool DeleteRequested { get; set; }
    public bool DuplicateRequested { get; set; }
    
    public override void RenderRectContent()
    {
        // Render plugin UI controls
    }
}

​
Reporting Issues

While contributions aren’t accepted yet, you can report issues:
  1. Check existing issues
  2. Provide detailed reproduction steps
  3. Include system information:
    • OS and version
    • .NET SDK version
    • Build configuration (x86/x64, Debug/Release)
  4. Attach logs and error messages

​
Feature Requests

Before suggesting features, review the roadmap:

​
Currently Working Features

  • Audio and MIDI playback
  • Track rendering and controls
  • Built-in and VST2 plugin support
  • Piano roll (partial)
  • Grid snapping
  • File preview

​
Not Yet Implemented

  • Audio clip editing view
  • Audio clip warping
  • Plugin grouping
  • Track grouping
  • Parameter automation
  • Project saving and loading
  • Audio export
Features marked in bold are critical for production use.

​
Learning Resources

​
Understanding the Codebase

Architecture Overview

Learn about Lumix system architecture

NAudio Documentation

Audio library used for playback and processing

ImGui Documentation

Immediate-mode GUI framework

VST SDK

VST.NET wrapper documentation

​
Future Contribution Opportunities

While contributions aren’t accepted now, the project may open up when:
  • Core architecture stabilizes
  • Essential features are implemented (save/load, export)
  • Code quality reaches production standards
  • Testing infrastructure is established
Follow the repository for updates on when contributions will be accepted!

​
Community

Stay updated:
  • GitHub Repository: ImAxel0/Lumix
  • Development Branch: Development - Latest commits
  • Issues: Report bugs and track progress

​
License

Check the repository’s LICENSE file for usage terms and conditions.

Ready to Build Plugins?

Learn how to create custom audio processors and effects for Lumix

Build docs developers (and LLMs) love

Get started for freeTalk to us