Open to python & full-stack roles
Engineering new languages, compiler pipelines, low-level systems and native environments.
Arc is a lightweight programming language written in C, featuring a custom lexer, parser, and interpreter. It supports variables, functions, control flow, and a minimal standard library.
Keywords are Case-Insensitive: Control frameworks like VAR, FN, IF, WHILE, TRY, and RETURN accept any matching casing standard dynamically.
Identifiers are Case-Sensitive(myVariable and myvariable are separate instances).
isTruthy(Value v).
Integers and floats evaluate false when equal to 0 or 0.0.
null is also false.
Objects are truthy except:
empty strings and empty lists.
Classes are built utilizing the CLASS keyword. Methods skip hidden structural context binding overlays - meaning instances have to get fed explicitly through the argument frame to process scope modifications.
CLASS Entity
VAR field = "abc"
FN func(instance, updatedValue) THEN
instance.field = updatedValue
END
END
VAR actor = Entity()
actor.func(actor, "new_state")
src/lexer.c parses source inputs into distinct structures.src/parser.c produces a optimized ASTNode tree.src/compiler.c targets memory arrays called Chunks while resolving variable scopes.src/vm.c runs instructions through an optimized stack framework utilizing computed gotos.Leverages src/memarena.c for persistent AST phases alongside custom recycling pools in src/mempool.c to reduce structural overhead.
Natively provisions operations such as print(), len_of(), and math files like math.arc via explicit runtime inclusions.
An asynchronous Python web routing engine built completely over native ASGI. Designed from the bottom up to serve direct data-streaming microservices without introducing the bloat and middleware overhead.
Nebula sidesteps complex multithreading frameworks by executing over standardized state events. It provides micro-routers with flat lookups, achieving predictable throughput for real-time web applications.
from nebula import Nebula, run_prod
app = Nebula("127.0.0.1", 5000)
@app.get("/")
async def home():
return {"status": "routing_active", "engine": "nebula_core"}
if __name__ == "__main__":
run_prod(app, workers=4, access_log=False)
A lightweight, real-mode 16-bit operating system written entirely in x86 Assembly. Features a multi-stage sector bootloader, native console shell interfaces, and low-level interrupt hooks communicating directly with hardware.
Programs communicate with the underlying kernel by preloading explicit identifiers inside the ah register block before issuing interrupt calls:
| Syscall Tag | AH Op | Parameters | Functional Objective |
|---|---|---|---|
| sys_print_char | 0x00 | al = character byte | Writes an individual token directly to the screen view. |
| sys_print_string | 0x01 | si = pointer reference | Processes null-terminated text streams to terminal screens. |
| sys_print_newline | 0x02 | None | Moves cursor to new line. |
| sys_shutdown | 0xA0 | None | Signals APM parameters to shut down system operations. |
Adding custom utilities involves building targeted instruction sets inside the program registry before wiring them into the system layout checks.
; target logic written inside progs/custom_print.s
user_extension_entry:
mov si, display_message_pointer
mov bl, 0x0F ; Light white text attributes
call print_string_utility
ret
display_message_pointer: db "Custom User Vector Triggered.", 0
An AI-assisted study companion application that transforms handwritten logs and document streams into customizable training tools. Features automated quiz generators, summaries, and OCR for PDFs and images.
Transforms inputs (including TXT, PDF, and image text extractions) into formatted reference frameworks via OCR preprocessing layers.
Maps dynamically updating study outlines by analyzing target timelines, specific files, and personal learning preferences.
Maintains persistent message contextual tracking, giving users the power to converse with files and query complex technical configurations.
Google OAuth authentication with multi-language user interface support.
Running 30s test @ http://127.0.0.1:5000
4 threads and 900 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 20.72ms 35.79ms 1.16s 99.40%
Req/Sec 12.18k 1.18k 16.08k 69.92%
1455071 requests in 30.05s, 194.27MB read
Requests/sec: 48418.20
Transfer/sec: 6.46MB
single-threaded, warm cache, best of 5 runs Fibonacci (recursive, n=30) | Arc faster (~1.49x) Fibonacci (iterative, n=1000) | Arc faster (~2.38x) Sum 1..1,000,000 | Arc faster (~2.47x) String concat (x10,000) | Python faster (~4.34x) List build (x1,000) | Python faster (~1.25x) Nested loops (1000x1000) | Arc faster (~1.96x) Recursive countdown (5000) | Arc faster (~2.14x) Variable churn (x100,000) | Arc faster (~2.19x) Arc wins 6/8 benchmarks