Independent developer · Language designer · Open-source builder
Block Language · Official website
I build practical software from first principles, with a current focus on programming languages, execution engines, developer tools, and clear technical documentation.
My main project is Block Language: a local-first, polyglot programming language and execution engine designed to bring several runtimes into one readable workflow. The goal is simple: make it easier to combine languages, share state, test ideas, and turn small scripts into useful tools without hiding the execution model.
I care about more than adding features. I also work on release reproducibility, installer safety, actionable error messages, documentation, testing, and a development experience that makes sense on a real computer.
| Area | Focus |
|---|---|
| Main project | Block Language |
| Core interests | Language design, runtimes, developer tools |
| Working style | Human-led, AI-assisted, openly documented |
| Current priority | Stability, safety, reproducibility, and usability |
| Preferred communication | English or Traditional Chinese |
Block Language is my primary open-source project.
It explores a document-oriented way to run polyglot programs, including workflows involving Python, JavaScript, Lua, PHP, SQL, and native tools. A Block document can describe multiple language sections while the engine coordinates execution and shared state.
Current areas of focus include:
- Core engine stability and predictable execution
- Clear diagnostics for syntax, runtime, and environment errors
- Safer Windows installation and release verification
- Better command-line workflows with less path configuration
- Examples and documentation for new users
- Testing across supported runtimes and release artifacts
- A dependable foundation for future libraries and tooling
The project is developed through a human-led, AI-assisted workflow. I make the product decisions and review the results; AI tools help explore designs, identify edge cases, draft documentation, and accelerate iteration. The final goal is software that remains understandable, testable, and useful to people.
Block is designed around readable sections that keep each language boundary visible:
<py>
message = "Hello from Block"
print(message)
</py>
<js>
console.log("The document can continue in JavaScript.")
</js>
The example is intentionally small: clear boundaries make it easier to understand what runs, what state is shared, and where an error comes from.
| Project | Description |
|---|---|
| Block Web Runtime | Experimental work exploring how Block-style execution could become more accessible through the web. |
| 2048 Game | A practical game project used to explore interaction, structure, and implementation details. |
| Block | An earlier stage in the development history of Block Language. |
| Block_ | A middle-stage prototype and historical reference for the project. |
The profile's native contribution graph remains the source of truth for GitHub activity. These visual charts are stored in this repository, so the page does not depend on an external chart host.
This visual summary is maintained in the profile repository and uses the same monochrome visual language as Block.
I am continuously studying the ideas behind languages and tools I use or want to understand better:
- Python for automation, testing, and rapid experiments
- C++ for runtimes, performance, memory, and systems programming
- JavaScript and web technologies for accessible developer experiences
- Language design, interpreters, compilers, bytecode, and runtime boundaries
- Secure distribution, reproducible builds, and software supply-chain safety
-
Make the behavior understandable.
Good tools should explain what they are doing and why something failed. -
Treat stability as a feature.
A new capability is only valuable when it remains predictable under real use. -
Document the boundary.
Users should know what runs locally, what requires an external runtime, and what permissions are involved. -
Build in public.
Issues, tests, release notes, and honest limitations are part of the project—not decoration. -
Use AI as a collaborator, not a substitute for judgment.
Human direction, review, and responsibility remain essential.
I am interested in meeting developers, testers, language enthusiasts, educators, and curious users who want to:
- Try Block Language with small, reproducible examples
- Report bugs or unclear documentation
- Discuss language design and runtime architecture
- Improve examples, tests, translations, or developer tooling
- Explore safe ways to make polyglot programming more approachable
If you test a project, a minimal reproduction, expected behavior, actual behavior, and environment details are always helpful.
- GitHub: github.com/O-O1112
- Block Language: github.com/O-O1112/Block_lang
- Official website: o-o1112.github.io/Block_lang
Thanks for visiting. I am building carefully, learning in public, and improving one release at a time.