BrickHouse Software · BKH · Independent studio
Custom software
for difficult problems
We build new software, rescue systems that aren't working, and modernize technology your business still depends on.
Called when…
- “Our developer disappeared.”
- “We've outgrown spreadsheets.”
- “Nobody understands this old code.”
- “The prototype isn't production-ready.”
- “Off-the-shelf software doesn't fit.”
- “We have a bug nobody can reproduce.”
- Operating
Open1320 Legends
Desktop game client · live multiplayer
- Shipped
Developer platform (NDA)
Tiered interfaces · production rollout
- Ongoing
Rescue & modernization
Inherited codebases, legacy systems
- 2 slots
New engagements
Discovery calls this month
[ 01 ] Build
Build from scratch
When off-the-shelf software doesn’t fit, we build around the way your business actually works: web apps, internal tools, platforms, backends, and automation.
[ 02 ] Rescue
Rescue what exists
Inherited code, abandoned projects, unfinished builds, hard-to-find bugs, and systems nobody fully understands anymore.
[ 03 ] Modernize
Modernize without starting blind
We understand the existing system first, preserve what still works, and replace only what is holding it back.
Sound familiar
BrickHouse is usually called when…
If one of these is your situation, you're in the right place.
The proof
Shipped systems you can audit
Real engagements, measured results, written down. Read them, or browse the full work hub.
Flagship · Public showcase
Open1320 Legends
Legacy platform reconstruction: client, multiplayer backend, economy, and a database rebuilt from merged, inconsistent data.
- Runtime
- Dead → live
- Authority
- Client → server
- Data
- Merged → normalized
Client engagement NDA-safe
Developer Platform Hardening
A multi-tier prototype that fell over, made to survive a real beta — crash recovery and reconnects as features, not afterthoughts.
- Soak
- Zero crashes / 24h
- Reconnect
- 100 of 100 passes
- Scope
- Fixed SOW
Client engagement · In packaging
Recent client build
A completed commercial engagement being written up now: scope, approach, and measured results, published once the client sign-off is in.
Ask about references
Signature offering
Inherited software nobody understands?
You don't necessarily need a rewrite.
Send us the repository, the application, the logs, the documentation — or whatever you actually have. We'll determine how it works, what is broken, what is worth keeping, and the safest path forward. You get written findings and a scoped fix, not a sales pitch for a rebuild.
Start a technical investigationServices
What we do
Four capability areas. Most projects touch two or three at once.
Custom Software Development
Apps, internal tools, portals, APIs, and databases built around your workflow.
Software Rescue & Modernization
Legacy code, inherited systems, unfinished projects, and reverse engineering.
Automation & AI
Business workflows, data processing, and internal AI tools that save real hours.
Infrastructure & Reliability
Servers, deployment, diagnostics, QA tooling, and monitoring that holds.
Ownership
You own what we build
Your source code, repositories, credentials, databases, and documentation are handed over to you. BrickHouse doesn't hold your software hostage to keep you paying us.
- Source code and repositories
- Server and service credentials
- Databases and schemas
- Handover documentation
Featured work
Open1320 Legends
A full multiplayer racing platform — client, servers, database, and tooling — and the proving ground for everything above.
Flagship project · Legacy desktop client → modern platform
What started around the old Nitto 1320 Legends ecosystem became a serious engineering effort: SWF decompilation and AS2/AS3 analysis, a rebuilt client architecture, multiplayer networking, room and lobby systems, authentication, player state, telemetry, and a database rebuilt from merged, inconsistent data.
The rule throughout: preserve what made the original work, and remove the technological limitations that came with its original architecture. It is a legacy modernization project disguised as a racing game.
- Reverse engineering and analysis
- Multiplayer networking and room state
- Backend services and authentication
- Database merges and normalization
- Race telemetry and diagnostics
- Modern UI, assets, and tooling
How starting a project works
Tell us the problem → We look → You get a scope → We build
The buying process, not the engineering process. No technical specification required to start.
Tell us the problem
You don’t need a technical specification. Plain language is enough.
We look at what you have
Code, documentation, screenshots, servers, requirements — whatever actually exists.
You get a scope
Deliverables, approach, milestones, price, and what “done” means — in writing.
We build
Work is delivered in measurable increments against real data, not mockups.
Projects range from focused technical investigations to complete multi-month software builds. Every engagement gets a written scope and price before development begins.
See engagementsWhat we do differently
Understand → Disassemble → Architect → Rebuild → Test → Deploy
Nothing gets rewritten before it is understood. That order is the whole method.
Understand
Before anything is changed, the system gets read: code, data, logs, traffic, and whatever documentation survived. Hard problems are usually just undocumented problems.
Disassemble
The system is taken apart into its real components — clients, services, protocols, schemas — and mapped, including the parts that were never meant to be looked at.
Architect
A target architecture and migration path, written down. What gets preserved, what gets replaced, what order it happens in, and what the risk is at each step.
Rebuild
Work lands in visible increments against real data. Backend, protocol, and data layers first, then the interface, so progress is running software rather than mockups.
Test
Regression harnesses, telemetry, and instrumentation. Edge cases, bad input, failure paths, and synchronization — verified server-side, because client-side checks are decoration.
Deploy
Shipped and operated: SSL, process management, backups, logs, monitoring, and restart-on-crash. Handover docs and ongoing support available, never mandatory.
The BrickHouse approach
Hard problems are usually just undocumented problems
BrickHouse is the umbrella. Select an area to see concrete examples of what was actually built, shipped, and kept running.
Contact
Have a system that needs to be built, rescued, or modernized?
Describe what you have and what it needs to do. You'll get a straight answer on whether we can help, roughly what it takes, and what it costs.