BlackHouse AudioWare Forge

Forge is a native MacOS design tool that lets audio creators build a hardware interface for both physical manufacturing and plugin UI.

Comment

Forge

Inspiration

Designing audio hardware is surprisingly fragmented.

When creating a guitar pedal, rack processor, or other piece of studio equipment, I found myself constantly switching between multiple applications: one for electronics, another for mechanical design, another for graphics, and another to prototype the software interface. Every change meant updating several independent files and hoping they all stayed synchronized.

I wanted a single workspace focused specifically on audio hardware design.

Forge was created to bridge that gap: one project, one source of truth, multiple outputs.

This project was also an experiment in a new way of building software. As an audio engineer rather than a Swift developer, I collaborated with OpenAI Codex to transform a product idea into a native macOS application. The result demonstrates how domain expertise and AI-assisted software engineering can dramatically reduce the barrier between an idea and a working product.

What it does

Forge is a native macOS application for designing audio hardware.

Users can create projects, design pedal and hardware front panels, position controls with millimetre precision, generate manufacturing-ready layouts, and build matching plugin interfaces from the same design data.

Instead of treating hardware graphics, drilling templates, and software interfaces as separate workflows, Forge keeps everything connected inside a single project.

The Build Week version expands Forge into a project-oriented platform with support for multiple hardware formats, laying the foundation for pedals, rack units, and 500-series products within one unified workflow.

How I built it

Forge is written entirely in Swift using native macOS technologies.

I developed the project through an iterative collaboration with OpenAI Codex.

Rather than generating code once and accepting the result, the development process consisted of hundreds of design decisions: defining workflows, reviewing implementations, identifying UX problems, redesigning architecture, refining interfaces, testing functionality, and iterating until the software matched the workflow I envisioned.

While Codex handled the implementation, I focused on product direction, audio engineering knowledge, workflow design, testing, and feature prioritization. As someone who is not a Swift developer, this project became an exploration of what AI-assisted software engineering can enable when paired with deep domain expertise.

Challenges I ran into

The biggest challenge wasn't writing code—it was designing the right product.

Audio hardware follows workflows that general-purpose design software doesn't understand. Creating an interface that feels natural for pedal builders while remaining flexible enough to expand into rack equipment and future hardware formats required several architectural redesigns.

Another challenge was maintaining simplicity. Every new feature had to make Forge more capable without making it harder to use.

Finally, AI-assisted development still requires engineering judgment. Generated code can be produced quickly, but every implementation had to be reviewed, tested, and validated against real-world audio engineering workflows.

Accomplishments that I'm proud of

  • Building a native macOS application despite not being a Swift developer.
  • Creating a project-centered workflow instead of another collection of disconnected utilities.
  • Demonstrating that AI-assisted software engineering can produce specialized professional tools.
  • Establishing an architecture capable of supporting multiple audio hardware formats.
  • Turning an idea into a working application in only a few weeks through continuous collaboration with Codex.

What I learned

The biggest lesson was that AI works best as an engineering collaborator rather than a replacement for product thinking.

Codex dramatically accelerated implementation, but the quality of the final application still depended on defining clear requirements, evaluating trade-offs, and continuously refining the user experience.

I also learned that domain expertise matters. Understanding how audio engineers actually work allowed me to guide implementation decisions that a coding model could not infer on its own.

Perhaps most importantly, I discovered that modern AI tools make ambitious software projects accessible to people who understand a problem deeply, even if they are not experts in the implementation language.

What's next for BlackHouse AudioWare Forge

Forge is intended to become a complete audio hardware design platform.

The roadmap includes:

  • 3D hardware assembly using KiCad models.
  • Expanded support for rack equipment and 500-series modules.
  • Amplifier design workflows.
  • Deeper integration with BlackHouse AudioWare's DSP development tools.
  • A unified environment connecting hardware design, DSP development, and product visualization.

The long-term vision is simple:

Design an audio product once, then generate everything needed to build it—from the physical enclosure to the software interface from a single project.

Built With

Share this project:

Updates