ABOUT / A LITTLE CONTEXT

ailiheizi

爱丽黑子

Software development · AI applications · Visuals & interaction

Explore through code. Express through what I make.

A little about me

I started coding in middle school. I enjoy how one small question leads to others: where a request goes after leaving an interface, why a piece of code works the way it does, or what an idea could become. Following those questions has taken me from software into AI, devices, and film. I like taking the time to understand them, making something, and refining it through use. Open source has taught me a lot, and I’m glad to share my own experiments too.

Software development

I have developed backends and tools with Go, Python, Rust, and TypeScript, and web, desktop, and mobile applications with Flutter, React, and Vue. In a team, I can contribute to requirements, technical design, implementation, testing, and deployment, connecting interfaces, services, and data processing into working features. Each project has different needs; I choose tools around those needs and refine the implementation through use.

Technical details

Business data and form state: In the Echo demo workbench, I connected profiles, four record types and a timeline, implementing form validation, query filters and follow-up dates. Generated suggestions support recorded outcomes, completed follow-ups and reopened records, covering state changes from data entry through follow-up.
Content identity and multiple sources: In the Cairn development preview, I separated content identity from source paths, allowing one content item to reference multiple sources. Documents, photos and music reuse query, selection, tagging and favorites logic, with linked detail views and a music queue.
Range selection, batch changes and revision checks: For Cairn’s range selection and batch tagging, mutations include the workspace, target objects and client-expected revision. When a write has an uncertain outcome, the client reads the actual state before proceeding and checks that the visible selection matches the mutation.
File staging, ZIP export and integrity checks: In Cairn’s file workflow, I separated staging from confirmed writes and implemented original-file export as ZIP tasks with progress and cancellation. Export checks each file’s length and hash and connects task state to the resulting files.

React / Vue
TypeScript
Go · Python / FastAPI
SQLite / FTS5
SSE / WebSocket

Shared Rust core and cross-platform bridges: In a collaboration on a file-processing product, I connected a shared Rust core to Flutter, Tauri and Web clients, integrating image, document, PDF, data and media conversion. Clients provide the interface, the core encapsulates conversion capabilities, and mobile clients call it through bridge interfaces.
PDF rendering and platform-specific processing: Where mobile lacked the desktop PDF rendering dependency, I selected processing paths by platform and requested output. Mobile uses the system PDF renderer, then passes rendered pages to local processing for image output and scanned-document conversion.
Local OCR and PDF text layers: I integrated local OCR with searchable-PDF output: the system renders document pages, and the shared core recognizes text and adds a text layer. For scans without embedded text, OCR results feed into the document-output workflow.
Dependency packaging and engine availability: I worked on bundling desktop conversion dependencies and integrated availability checks for the mobile media engine and Rust core. Conversion selects paths according to available capabilities; client integration covers dependency presence, engine calls and returned results.
Android configuration, state differences and log cursors: In the ModSpec prototype, I connected a desktop configuration tool to an Android agent. Configuration files describe the intended state; pairing precedes configuration delivery and device-state readback. I implemented change previews, intended-versus-actual state checks and log retrieval resumed from the previous read position.

Rust / FFI
Flutter
Tauri / Web
OCR / PDF
Android

Requirements, code review and delivery checks: I use AI coding tools for research, implementation and testing, while taking responsibility for requirements, architectural choices, code review, debugging and delivery checks. Actual inputs, execution feedback and outputs inform whether I keep a change, adjust it or investigate further.
Agent-host integration and workflow state: In a collaboration on a social-media workflow tool, I integrated existing agent-host sessions with source material, search, drafts, review and publication preparation. External tools perform publication; the interface manages content and operation state, separating frontend state management from execution responsibilities.
Demo resets, synthetic regression and output checks: I added demo-data reset to Echo for repeatable workflow checks. In the offline video tool, I wrote synthetic-video regression cases and re-decoded output to check redaction regions and frame counts. Checks match each project’s output and retain inputs and results for later inspection.

Requirements / Design
Integration
Code review
Debugging / Verification

AI & workflows

I have developed a modular AI workspace, an agent execution environment, and workflow tools that turn specific tasks into reusable Skills. These projects implement model connections, tool calls, composable capabilities, and permission checks. I have also verified Skill generation and reuse in a fresh session through a real workflow. Local inference with quantized models, selection tasks, retrieval, and tool routing are further areas of hands-on work. I focus on how a task runs from start to finish: whether execution can be inspected, results checked, and existing capabilities reused in the next task.

Technical details

Model APIs, request routing and protocol adaptation: I integrated OpenAI-compatible APIs into an AI workspace, separating request routing, key selection, protocol conversion and error handling. Model configuration and tool execution have separate responsibilities; streaming and non-streaming requests use distinct paths for request-level diagnosis.
MCP discovery and Skill execution constraints: I organized task goals, real tool bindings, failure handling and completion evidence into Skills, with a recorded example of reuse in a fresh session. I implemented MCP connections and tool discovery; a reference host checks exact tool names for explicitly scoped Skills and handles stale asynchronous results and turn cleanup.
CDP Screencast, WebSocket and SSE: In a browser-execution prototype, I streamed Chromium CDP Screencast frames over WebSocket to a frontend Canvas and returned conversation updates through SSE. Browser actions, model responses and page frames use separate channels, with visual and tool feedback for inspecting progress and debugging.
Candidate-ID protocol and confirmed writes: In a code-selection experiment, the host enumerates real candidates and the model returns only an ID or NONE. Parsing rejects unknown IDs, embedded code and extra control fields. The host uses saved candidate content; write approval binds the target, content hash and disk baseline. Changes to any of these require fresh approval before writing through a temporary file and atomic replacement.
Multi-source retrieval, SQLite caching and ONNX embeddings: I built multi-source retrieval for agents, normalizing results into JSON and using SQLite caching and a query ledger to distinguish query requests from actual source calls. I also implemented local ONNX vector encoding and cosine Top-K retrieval. The retrieval layer supplies candidates; the calling Skill handles research judgments.

Model API
MCP / Skills
Retrieval
Chromium CDP
Docker

Systems & networks

I have worked on Linux operations and virtualization deployments, and handled networking, messaging protocols, data storage, isolation, and access control in projects. Connection management, permission checks, persistence, and recovery after a service restart are parts of implementing a feature. I like tracing a request through the system, understanding how the steps work together, and considering a feature within the system as a whole.

Technical details

WASM capability packages, permissions and circuit breaking: In a Rust / WASM runtime, I packaged capabilities as loadable modules, working on signature checks, permission declarations and permission differences introduced by upgrades. Package-level circuit breaking controls further calls after failures; model-provider routing and error handling remain in a separate request pipeline.
Store / Peer separation and protocol interfaces: In a messaging research prototype, I separated message storage and relaying into Store and Peer nodes, connected nodes over WebSocket / Protobuf and exposed message, contact and room APIs through REST. Traits separate storage, search and transport, with UniFFI bindings for client integration.
Parent references, SQLite persistence and Tantivy search: The research prototype represents relationships through parent-message references, checks missing parents and orders currently known messages by depth, local receive time and hash. I also implemented relay digest checks, SQLite persistence and Chinese search with Tantivy, connecting message relationships, stored records and query interfaces.
Container lifecycle, resource limits and operations: I used Docker / Compose to organize gateways, tool services and execution environments, managing per-user container creation, reuse, keepalive and reclamation with resource limits, network boundaries and callback verification. In Linux operations and virtualization deployments, I also helped investigate service recovery, networking and virtual-machine lifecycle issues.
ARM64 cross-compilation and CI artifacts: In historical build work based on an open-source kernel, I modified GitHub Actions and Docker configurations, integrated Clang / LLVM and KernelSU, and connected ARM64 image builds to artifact uploads. My work focused on build scripts, toolchains, dependency integration and CI environment differences.
Atomic generations, state transitions and rollback: I built a Rust workspace prototype exploring reproducible package management, organizing state changes into atomic generations, implementing rollback modules and writing verify tests. The prototype considers transitions between old and new states, checks around changes and recovery paths.

Rust / WASM
WebSocket / Protobuf
Linux
Docker / Compose
CI

Vision & hardware

I have built camera-based gesture recognition linked to a robotic arm, using OpenCV and MediaPipe to turn visual input into device actions. I have also worked on projects involving ESP32, serial communication, and device control. This work brings visual input, device communication, and physical feedback together, connecting software logic to actions in a real environment.

Technical details

Detector fusion, track association and bounded backtracking: In an offline licence-plate redaction tool, I combined candidates from multiple detectors and linked frames through track association and motion prediction. Local re-detection and bounded backtracking extend planned redaction regions around brief missed detections or position changes before rendering.
Video re-decoding checks and release gates: After output is written, the tool decodes it again to check frame counts and planned redaction regions. Failed default checks discard the draft; passing checks permit publication. A separate release flow binds the input to its human-review result to check that processing and review refer to the same input.
ESP32, TCP commands and GPIO feedback: In ESP32 exercises, I received control commands over Wi-Fi and TCP, changed GPIO state and returned feedback. Device integration checks sent commands, received results and physical actions. I also used serial communication to inspect device connections and command execution.

OpenCV / MediaPipe
Detection / OCR
ONNX / FFmpeg
ESP32
Serial / TCP

Games & films

Games and film give me another way to express an idea. I have contributed to a collaborative Godot game and made a narrative short with AI assistance. Team members supplied the live-action footage and appeared on camera; I brought together the script, shot plan, generated images, sound, and editing with AI. In this work, I care about visual beauty, the pace of interaction, and whether the result communicates the feeling I want to express.

Technical details

Godot prototype and time-replay interaction: I contributed to the collaborative Godot game prototype ECHO. A character’s actions from three seconds earlier reappear as an Echo that helps the player move forward, using time replay in level interaction. The garden and world tree provide environmental storytelling.
Quest spatial panels and input adaptation: I developed a Quest adaptation of the open-source BiliPai client, placing existing pages in interactive spatial panels. I added a separate build entry and adapted panel grabbing, resizing, hover feedback, collapsible navigation and playback controls to connect spatial input with existing page actions.
Game mods, event integration and review state: I extended the open-source VocabSpire mod with active quizzes, a reward-currency shop, combos and question-based revival, connecting learning actions to combat events. I added mistake-notebook persistence, review triggers based on question progress and protective branches for new combat states in multiplayer.
AI-assisted scripting, generated visuals and editing: I created Echo’s script, shot plan, generated visuals, sound and final edit with AI assistance; team members appeared on camera and supplied live-action footage. Transitions, colour-temperature changes and editing pace follow the character’s rediscovery of interest and motivation to express it.
IPFS audio distribution and browser-side ONNX decoding: In an audio publishing and playback experiment, I stored encoded data, a model and metadata in IPFS, then retrieved the data for byte comparison. The browser fetches audio by content identifier, caches the model and decodes it with ONNX for playback, connecting data publishing, content storage and browser playback.

Godot / C#
Android / Quest VR
Interaction
AI-assisted film

Curiosity & learning

I learn by making things, and I like to ask why a tool or system works the way it does. I have worked with memory, concurrency, and builds in C++ projects and used x86 assembly in game-memory experiments. Computer science fundamentals, language internals, AI principles and applications, Android and Linux environments, and ArkTS are areas I continue to study. My experience varies by field; I enjoy connecting the underlying ideas and following questions through reading, discussion, and hands-on work.

Technical details

C++ TCP, thread synchronization and asynchronous tasks: In C++ networking and concurrency exercises, I wrote TCP clients, servers, multithreaded services and asynchronous tasks, coordinating worker threads with locks and condition variables. Runnable programs test connections, waiting and synchronization, including task organization with future / async.
C++ compilation, linking, rpath and build configuration: I worked through C++ compilation, linking and rpath options, using xmake and CMake for local builds. These exercises check compiler arguments, library dependencies and runtime search paths, distinguishing issues in compilation, linking and program loading.
C++, x86 assembly and process-memory experiments: In a personal Plants vs. Zombies memory experiment, I used C++, x86 assembly and Windows APIs to inspect game functions and process memory. I explored reproducing function calls and writing and executing code in the game process, relating the displayed sun value to memory addresses and function calls.
Termux, module scripts and rclone mounts: In Termux, KernelSU and Zygisk environments, I worked with permissions, modules and script integration, along with rclone mounts. This practice focuses on Android / Linux command-line environment configuration, tool integration and troubleshooting.

C++ / TCP
Thread / Future / Mutex
gcc / g++ / rpath
xmake / CMake

Write code. Build systems. Give imagination a picture.

CONTACT / LET’S TALK

Tell me what you’d like to build.

I’d be glad to talk about AI applications, productivity tools, software products, or creative projects, and I’m open to longer-term technical collaboration. We can start with an idea, a problem you are working through, or an existing project. If the direction is still taking shape, we can work it out together.

me@alhz.org

Alternative email
ailiheizi@gmail.com

GitHub