Hi, I’m Xuepoo

You can call me “Swe-poo”.

I’m currently an undergraduate studying software engineering. Back in middle and high school, I spent six years studying math on my own. When I went to college, I chose software engineering, so I usually end up thinking through things with a mathematical mindset.

I really like looking into why software is designed the way it is, and I also like asking: if we don’t just follow the existing path, is there another way to do it?

Still, I don’t want this page to just be a stiff resume. I also wanted to leave behind the music, manga, and mystery novels I like, along with those slightly hazy future dreams from early computers and the web.

I like thinking complex things through clearly, and I also like making things for no specific reason, just because they feel fun.

Starting with a Line of C

The summer after high school graduation, I started teaching myself C. Once I got into university, I got into ACM, Codeforces, and competitive programming, and later learned Java Web. My interest gradually shifted from “how to solve a problem” to “how to design and maintain a real software system.”

Because I’ve been studying math from middle school all the way until now—geometry, probability, functions, calculus, graph theory—I always think about problems with a mathematical mindset. Or rather, I like bringing things I’ve learned, used, and built into new designs, especially the abstract structures that can connect seemingly unrelated things together.

For example, when you learn a lot of math methods, you can solve a problem in different ways, and you can do the same thing in software development. As a result, a lot of what I build ends up being infrastructure rather than application layer stuff. It feels a lot more like applied research than ordinary software development.

Things I’ve Made

Before my junior year, I mainly worked on school projects and external projects. Starting in the second semester of my junior year, I mostly worked on things I was personally interested in, building them around my interests as open-source projects. Many of these are closely tied to the math I studied before.

I’m interested in quite a lot of fields, like Web frontend and backend, big data tech, cloud computing, computer networks, the Linux operating system, computer graphics, AI Infra, and so on.

Right now, I personally maintain 30+ websites (mainly on Cloudflare), own 6 domains, maintain 10+ packages on the AUR, and have published 50+ libraries across platforms like npm, PyPI, crates.io, etc.

Here are a few projects I’ve built before that have some distinctive characteristics:

Vectomancy · Converting Images into Math Equations

Vectomancy is one of the formal projects I maintain. The inspiration came from mathematical art on Wolfram Alpha. It can compute corresponding mathematical equations for any image. It started out as just a CLI program, and later I compiled it to Wasm so it works directly on the web.

It might not be the flashiest thing I’ve built, but it means the most to me, because on top of that inspiration I went on to develop Topoglyph, VectoJS, and CapGlyph.

VectoJS · Canvas-Native UI Runtime

VectoJS is a Canvas-native UI Runtime that uses a virtual math tree for layout.

For its earliest inspiration, you can read the post at https://blog.xuepoo.xyz/posts/vectojs-de-dan-sheng-yuan-you/ . Simply put, I wanted every part of a web page to be rendered via Canvas rather than lots of DOM nodes. There were a ton of things to consider here, like how to handle interactions, and how to select and render text.

The website explains the various tough challenges involved. Before I started working on Bitty later on, this was easily the hardest project I’d tackled. Its design draws heavily on mathematics and involves dealing with multiple browser rendering engines—this was my first real realization of how tough compatibility is in software development.

This project also branched out into streaming Markdown rendering, danmaku design, knowledge graphs, animations, and various visualization experiments. It’s the project I’ve dogfooded the most in my own development, spending an enormous amount of time on software testing, E2E tests, and so forth.

This is frontend infrastructure I built, but under the hood it’s all math, low-level browser rendering, and computer graphics knowledge.

CarryCtx · A Project Management Tool Around Agents

While developing VectoJS, I noticed a few pain points:

So I thought about the designs of Git and SQLite, and combined the two into CarryCtx. Since then, all my projects have been managed with it. I’ve used it long-term across many subsequent projects, and it’s gradually become an indispensable part of my daily development workflow. It’s probably the most practical software I’ve built to date.

Here’s the intro from the project website: A coding Agent team depends on a body of state that no single person can reliably keep in their head long-term: what tasks exist, why they exist, what depends on what, who owns what right now, and what has already been tried. When the commander is responsible for planning, role-specialized sub-agents handle implementation, and reviewers wrap things up, these intentions quickly outgrow any single chat window. Commit messages explain patches, not plans; Markdown notes go stale the moment someone stops updating them by hand.

Bitty · A Programmable Modern Terminal Emulator

Bitty is a long-term Rust terminal emulator project I’m actively developing. If VectoJS was the hardest project I’d done in terms of local feature complexity, Bitty is the best reflection of my overall software design thinking. It’s closely tied to my major, so I chose it as my graduation thesis project.

The inspiration came from Neovim: I wanted to build a core that is sufficiently reliable and as small as possible, leaving freedom of experience to composable mechanisms and extensions, rather than constantly stuffing features into the core. Later inspiration also came from Emacs, Kitty/WezTerm/Alacritty, and Hyprland.

Before building this project, I spent a lot of time thinking and researching. I knew right from the start that it wouldn’t be easy. It’s a microkernel architecture split into many distinct software layers. I didn’t just innovate at the runtime level—I also introduced distinctive designs in the UI architecture and extension architecture. The extension architecture design is what I consider my best work; for details, check the docs at https://bitty.run .

Building this project came with a lot of pressure, especially because the network stack design took me a very long time to think through before settling on its current state, including a minor refactor along the way. Only after that did I truly realize how vital software design is, and why I’m drawn to infrastructure and mathematical thinking. I started trying to summarize the core design philosophy of a software system in a single sentence: what it fundamentally is, and through what mechanism it achieves its goal. A single sentence can’t explain a full system architecture, but if even the most important core abstraction is hard to state clearly, I rethink the design. Examples include:

What they have in common: a single sentence that states both “what it fundamentally is” and “what mechanism buys it”, without empty buzzwords or subjective adjectives like “high performance / easy to use.”

I believe software should be built this way rather than bragging about how many features were implemented. That’s what I care about, and it was only from this point onward that I realized what I do is primarily applied research rather than mere application-level development.

Wheel · An Agent Running on Bitty

I thought up Wheel while designing Bitty. Nowadays, any software needs AI integration or users won’t adopt it. For Bitty, that meant having the bitty-ai extension, along with an official plugin acting as an Agent tool.

So I researched and designed it myself, drawing on things I’d learned and used before—namely Git and graph theory. Wheel originally came from thinking about Bitty Panel, Workspaces, and multi-Agent collaboration. I wanted to view Agents as workers with distinct roles, tasks, and collaborative relationships, rather than just a single tool call from a primary Agent.

As the design evolved, Wheel became an independently running Coding Agent Harness. Bitty provides the interactive UI and workspace, while execution permissions, task strategies, and context management are handled by the Harness itself. This also led me to rethink the relationships between Agent topology, task lifecycles, and runtime boundaries. Here, Agents are structured like people in a company: each has their own seat and role, assigned tasks, and can communicate with leads—not just a single flat layer of Main Agent calling Subagents. So I used a lot of graph theory to design this topology.

As for context management, it borrows from Git’s design. This part was designed entirely on my own, though it’s still being validated.

Both this project and Bitty are currently in preview and haven’t officially shipped. Wheel will be complete once Bitty implements its background daemon.

Mathen · Finding Mathematical Structures in Software Architecture

Mathen is a software architecture research project that is still actively being explored. It’s the most advanced, cool, forward-thinking, and unconventional project I’ve ever worked on.

The question I want to explore: can architectural mechanisms that recur across different software systems be abstracted, compared, composed, and verified under explicit evidence, hypotheses, and constraints?

This idea came to me after building Bitty. Initially, I wanted LLMs to use pure math to understand the underlying designs of systems like Git—at the deepest foundational level, rather than through code or flowcharts. The LLM provided numerous mathematical branches, analyzing things from different mathematical perspectives and surfacing fields I hadn’t encountered before, like order theory, lattice theory, patch groupoids, noncommutative algebra, homotopy, and so on.

Then I realized that LLMs are uniquely well-suited for problems requiring both depth and breadth of knowledge. So I created Mathen, taking more than 200 software systems, converting them from a macro view to a micro mathematical view, and then back into software architecture, turning it all into a knowledge graph to discover new software designs under novel constraints.

This process happens all the time in the physical world, but nobody had really applied it to software systems. People mostly focus on localized research like algorithms rather than researching software architecture itself, because this area is notoriously difficult. You can compare it to fields like pharmacology, cellular biology, or materials science, where you find patterns at a microscopic level to make new discoveries.

A great example is analytic geometry, which was born in the 17th century. Before that, algebra and geometry were already very mature, but solving many engineering problems with math alone was tough, so analytic geometry was born to describe geometry using algebra. The same can be done for software design.

This project is still in the research stage and has the biggest potential of anything I’ve worked on. Before this, the project with the most potential might have been CapGlyph, but that takes a very long time and requires patent applications, so I put it on hold for now.

Other Projects I’ve Made

Besides these, I’ve built quite a few other things. Here are some of them:

Of course there are others, which you can see at https://github.com/Xuepoo , but the rest are mostly small tools or scripts without super high technical complexity.

Campus Life Beyond Code

Outside of personal projects, I’m responsible for daily lab management, onboarding training, and event organization. I handle maintenance for our college’s Online Judge (OJ) system, and have organized student exchanges and events. Through these experiences, I’ve developed solid team organization and coordination skills—I really like bringing people together to get things done.

I’m also the psychological committee member for my class, organizing class mental health salons and keeping an eye on how everyone is doing emotionally.

Campus life feels really busy. Because I had some rough experiences back in middle school, my MBTI personality is ENFJ, and sometimes feels like INFJ. I naturally pay attention to things around me, even small things that might end up being deeply connected. Just like how I study math, I like seeking proofs—everything can be explainable. When people around me have disputes, I put myself in their shoes to understand why it happened and how to resolve it with minimal fallout.

Because I’ve seen quite a wide variety of things and have a pretty big imagination, I can often connect things that are normally hard to link together—like when I built CarryCtx. I’m really not afraid of tackling difficult, challenging things that are beneficial to my growth; as long as I know it will help me learn, I’m more than willing to put in the time to grind through the toughest problems. Having that curiosity and the courage to try things out is the only reason I’ve been able to build so many interesting things.

Some Not-So-Technical Interests

Here are some of my interests:

Of course, I often find myself thinking about philosophy, writing fiction, making music, learning history, and things like that. I feel like in the future I might well become a novelist and create interesting things.

A lot of the time, I use emotional intuition and then lean on rational tools to bring it to life.

Find Me