DEV Community: Boy Offi9

I Got Tired of Making Normal Portfolio Websites, So I Built an OS Instead

Boy Offi9 — Thu, 24 Sep 2026 14:50:58 +0000

I Got Tired of Making Normal Portfolio Websites, So I Built an OS Instead

I wanted my portfolio to be more than a collection of pages saying what I can build.

They usually follow the same pattern:

About → Projects → Skills → Contact

So I decided to do something different.

I built Boy Offi9 WM — a browser-based personal operating environment where my portfolio is presented as an interactive desktop/mobile system instead of a traditional website.

It has a boot sequence, desktop, windows, app drawer, terminal, mobile interface, filesystem-style apps like about.md, projects, and skills.json, and a bunch of small details that probably didn't need to exist. 😅

The goal wasn't to recreate Windows, Linux, or Android. I wanted to build something with its own visual language and interaction model.

It's still a portfolio underneath everything.

The difference is that you don't just read it — you explore it.

I like taking familiar ideas, changing the angle, and giving them their own identity.

This is one of those experiments.

Build. Break. Understand.

👉 Try Boy Offi9 WM

HexForge Gateway: APK reverse engineering with Claude, running on your phone

Boy Offi9 — Thu, 24 Sep 2026 12:39:34 +0000

Reverse-engineering an APK usually means juggling jadx, apktool, adb, frida and a pile of terminal tabs. I built HexForge Gateway to put all of that behind one self-hosted API, and to expose it as native MCP tools so Claude can drive the whole workflow.

It runs entirely on-device (Termux + MT Manager on Android) or on a normal PC. No cloud, no accounts.

What it does

Everything flows through one model:

Workspace -> Workflow -> Jobs -> Tasks -> MCP Agents

8 agents: jadx, apktool, APKiD, adb, frida, a filesystem agent, an AI-provider agent, and apkmcp, a client for MT Manager's built-in APK MCP service
19 MCP tools exposing those agents to Claude Desktop, Claude Code, Cursor and other MCP clients
Job and Workflow engines to chain steps and track their state
Knowledge engine so findings from one task are available to the next
Live updates over WebSocket (task:update, job:update, workflow:update)
9 AI providers and a plugin system, if you want to extend it

Storage is local files by default, with Supabase as an opt-in backend.

Try it

git clone https://github.com/boy-offi9-inc/hexforge-gateway
cd hexforge-gateway
npm install
cp .env.example .env
npm run dev

The Gateway starts on http://localhost:8080 and prints copy-pasteable commands. Create a workspace:

curl -X PUT http://localhost:8080/workspaces/by-name/my-project \
  -H "Content-Type: application/json" \
  -d '{"targetLabel":"com.example.app"}'

Then register the MCP server with your client. The steps are in docs/MCP_SERVER.md.

Running it on a phone

The part I'm happiest with: on Android, the Gateway runs in Termux and talks to MT Manager's APK MCP over loopback, so the whole stack lives on one device. There's a step-by-step guide with screenshots in docs/MT_MANAGER.md, including the one setting (the floating ball) that keeps the service alive in the background.

How it's built

TypeScript, Fastify, Zod, Node 20+. Modules talk through an event bus. CI runs typecheck, build, a real smoke test against a live instance, and an MCP handshake check on every push. Releases are automated: bump the version in package.json and it tags and publishes.

What's next

Per-workspace scoping for WebSocket connections
A web interface
A watched folder for APKs on PC, instead of typing full paths
Streamable HTTP transport for the MCP server, so remote clients can connect
A proper unit and integration test suite

Use it responsibly

Only analyze apps you own or have permission to test.

MIT licensed. Feedback, issues and PRs are welcome:

boy-offi9-inc / hexforge-gateway

Self-hosted reverse-engineering workspace API — orchestrates jadx/apktool/adb/frida/APKiD via a job & workflow engine, exposed as native MCP tools for Claude. No cloud required.

HexForge Gateway

= 20">

AI-assisted APK reverse-engineering workspace API. Dispatches tasks to MCP agents (jadx, apktool, adb, frida, filesystem, MT Manager's APK MCP AI providers) and streams updates over WebSocket. Runs entirely on-device (Termux + MT Manager on Android) or on a normal PC - no cloud required.

Flow: Workspace -> Workflow -> Jobs -> Tasks -> MCP Agents, with modules talking through an Event Bus. MIT licensed. Contributing: run npm run typecheck && npm run build && ./scripts/smoke-test.sh before a PR - see CONTRIBUTING.md.

Getting started

npm install
cp .env.example .env
npm run dev

The Gateway starts on http://localhost:8080 and prints a banner with your workspaces and copy-pasteable commands. GET / returns the same as JSON - the quickest way to see what's here.

Core endpoints (request/response shapes are in the linked docs):

GET / - live cheat sheet - GET /health - service + config status
POST /workspaces…

View on GitHub

MatrixRainView — A Code-Driven Android Matrix Rain Rendering Library

Boy Offi9 — Sat, 05 Sep 2026 17:06:09 +0000

This is a submission for Weekend Challenge: Generosity Edition

What I Built

I built MatrixRainView, an open-source Android library that allows developers to easily add a fully customizable Matrix-style digital rain effect to their applications.

The goal behind this project was simple: make creative UI effects more accessible to Android developers without requiring pre-rendered GIFs, videos, or heavy animation assets.

Instead of playing back an animation, MatrixRainView generates the effect in real time using native Android rendering. This gives developers complete control over the visual experience and makes it easy to customize for different projects.

Features

⚡ Real-time Canvas-based rendering
🎨 Custom colors and themes
🔤 Custom glyph/character support
🌧 Adjustable rain speed and density
✨ Glow and fade effects
📱 XML and programmatic configuration
🔧 Lightweight and dependency-free design
📦 Easy integration using JitPack

The project is fully open source, allowing developers to freely use, modify, and build upon it.

I created this library as a way of giving back to the Android developer community by providing a reusable component that developers can use in their own creative applications.

Demo

Check out the demo application:

MatrixRainDemo

The demo showcases different configurations and customization options available through the library.

Code

Library source:

MatrixRainView

Demo application:

MatrixRainDemo

How I Built It

MatrixRainView was built using Kotlin and Android's custom View system.

Instead of relying on external animation files, the renderer uses Android's native Canvas drawing APIs to generate the digital rain effect frame by frame.

Some important design decisions:

Custom Rendering Engine

The animation is generated completely through code, allowing each character, movement, fade effect, and visual property to be controlled dynamically.

Performance Focus

The library was designed to remain lightweight while providing smooth animations by avoiding unnecessary dependencies and using Android's built-in rendering capabilities.

Developer-Friendly API

I focused on making customization simple, allowing developers to modify properties like:

Rain speed
Character density
Colors
Glow intensity
Character sets

through an easy-to-use API.

The result is a reusable Android component that developers can quickly integrate into their applications.

Prize Categories

No special prize category applies.

Final Thoughts

MatrixRainView started as an experiment in Android graphics and became an open-source tool for developers who want to add dynamic visual experiences to their apps.

I hope this project helps other developers create more interesting interfaces and inspires more open-source contributions.s gives developers complete control over the visual experience and makes it easy to customize for different projects.

I built a real, drop-in "Matrix rain" View for Android (not another Canvas tutorial)

Boy Offi9 — Fri, 04 Sep 2026 18:17:40 +0000

I've built plenty of little effects and demos before, but this is the first thing I've shipped that's an actual reusable library — not a gist, not a "here's how you'd do it" tutorial, not a GIF. Something you drop into a project with one line and it just works.

It's called matrix-rain-view — a configurable "digital rain" effect (the falling-glyph look from The Matrix) as a real, custom Android View.

Why not just another tutorial?

Every Matrix-rain tutorial I found was the same: a Canvas, a coroutine loop, some hardcoded green. Fine for a blog post, annoying to actually use — no lifecycle handling, no attribute API, speed tied to frame rate so it looks different on every device.

So I built it properly instead:

Real lifecycle — starts on attach, stops on detach. No leaks, no battery drain when it's off-screen.
Delta-time animation — motion speed is consistent regardless of device refresh rate, instead of speeding up on 120Hz screens.
A real attribute API — configurable via XML or code, not just a set of magic numbers buried in a draw() method.
Custom glyph sets — katakana, binary, alnum, or your own custom pool.

Install

Add JitPack to settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

Add the dependency:

dependencies {
    implementation("com.github.boy-offi9-inc:matrix-rain-view:1.0.1")
}

Usage

Full-screen effect:

<com.boyoffi9.matrixrainview.MatrixRainView
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:rainColor="#00FF41"
    app:rainSpeed="1.2"
    app:rainDensity="1.0"
    app:rainGlow="true" />

Or as a background behind real UI — just make sure it's the bottom child of a FrameLayout (a LinearLayout can't stack children):

<FrameLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <com.boyoffi9.matrixrainview.MatrixRainView
        android:id="@+id/matrixRain"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:orientation="vertical">
        <!-- your real UI -->
    </LinearLayout>

</FrameLayout>

Everything's controllable at runtime too:

val rain = findViewById<MatrixRainView>(R.id.matrixRain)
rain.rainColor = Color.parseColor("#00FFAA")
rain.speed = 1.5f
rain.density = 0.8f
rain.charSet = MatrixRainView.CharSet.BINARY
rain.glowEnabled = false

rain.pause()
rain.resume()

See it in action

I put together a small demo app showing it running as a background behind real content, with a live settings panel wired to every property (color, speed, density, fade, glow, charset) — no restart needed, updates the running animation immediately.

👉 matrix-rain-demo — screenshots, a screen recording, and a CI-built debug APK from the Actions tab.

Try it

Library: github.com/boy-offi9-inc/matrix-rain-view
Demo: github.com/boy-offi9-inc/matrix-rain-demo

MIT licensed. If you use it or have thoughts, I'd love a star or an issue — this is my first real reusable Android lib, so feedback's very welcome.