STREAMING BUFFER CHUNKS // 60 FPS SYNC
STREAMING BUFFER CHUNKS // 60 FPS SYNC
Engineering low-level network protocol stacks in C++, writing memory injection harnesses, and developing custom WebAssembly virtual machines requires intense analytical discipline. When spending months deep in compiler internals, pointer arithmetic, and GPU shader calculus, it is easy to view software engineering strictly through the lens of optimization and performance metrics.
However, true long-term technical mastery thrives on cross-disciplinary creativity.
Outside of my primary systems engineering and cybersecurity research, I actively channel my energy into creative side projects, community building, and multiplayer game design. These endeavors keep my curiosity sharp, allow me to experiment freely with new game mechanics, connect with talented peers, compose music, and share technical knowledge.
This retrospective outlines my upcoming roadmap across four creative horizons: building an independent gaming community and custom server infrastructure, organizing local tech events in my city, synthesizing electronic soundscapes in my idle time, and authoring deep-dive technical essays.
One of my most ambitious creative initiatives is building an independent gaming community and development collective alongside a close circle of passionate developer friends.
Our mission is not merely playing games; it is bringing our own original game ideas, proprietary server infrastructure, and persistent multiplayer worlds to life.
1. Active Concept Development Phase: My team and I are currently mapping out original game concepts, combat mechanics, progression loops, and systemic world lore. We prioritize deep, emergent gameplay where player decisions meaningfully impact the virtual environment.
2. Logic-First Architecture: Our execution roadmap is strictly structured to start with pure logic code before anything else. Before investing in 3D modeling, animations, or environment texturing, we author and unit-test headless simulation modules in Luau and C++ that execute game rules purely in memory.
3. Agile Prototyping on Roblox: We leverage Roblox as an agile proving ground to test combat feel, client prediction, and multiplayer balance with real players in our community, utilizing custom low-latency replication layers.
4. Proprietary Dedicated Server Infrastructure: As game concepts mature, our vision extends into self-hosted, high-tick-rate dedicated game servers engineered in Go and modern C++, featuring custom matchmaking, persistent state databases, and low-latency UDP packet routing.
Below is a prototype of the custom spatial replication grid we authored in Luau, designed to partition entity simulation and minimize network replication bandwidth across connected clients:
| 1 | local SpatialReplicator = {} |
| 2 | SpatialReplicator.__index = SpatialReplicator |
| 3 | |
| 4 | function SpatialReplicator.new(gridSize) |
| 5 | local self = setmetatable({}, SpatialReplicator) |
| 6 | self.gridSize = gridSize or 64 |
| 7 | self.buckets = {} |
| 8 | return self |
| 9 | end |
| 10 | |
| 11 | function SpatialReplicator:GetCellKey(x, z) |
| 12 | local cellX = math.floor(x / self.gridSize) |
| 13 | local cellZ = math.floor(z / self.gridSize) |
| 14 | return cellX * 73856093 + cellZ * 83492791 |
| 15 | end |
| 16 | |
| 17 | function SpatialReplicator:InsertEntity(id, x, z) |
| 18 | local key = self:GetCellKey(x, z) |
| 19 | local bucket = self.buckets[key] |
| 20 | if not bucket then |
| 21 | bucket = {} |
| 22 | self.buckets[key] = bucket |
| 23 | end |
| 24 | bucket[id] = true |
| 25 | end |
| 26 | |
| 27 | function SpatialReplicator:QueryNearby(x, z, radius) |
| 28 | local results = {} |
| 29 | local minX = math.floor((x - radius) / self.gridSize) |
| 30 | local maxX = math.floor((x + radius) / self.gridSize) |
| 31 | local minZ = math.floor((z - radius) / self.gridSize) |
| 32 | local maxZ = math.floor((z + radius) / self.gridSize) |
| 33 | |
| 34 | for cx = minX, maxX do |
| 35 | for cz = minZ, maxZ do |
| 36 | local key = cx * 73856093 + cz * 83492791 |
| 37 | local bucket = self.buckets[key] |
| 38 | if bucket then |
| 39 | for id in pairs(bucket) do |
| 40 | results[#results + 1] = id |
| 41 | end |
| 42 | end |
| 43 | end |
| 44 | end |
| 45 | return results |
| 46 | end |
| 47 | |
| 48 | return SpatialReplicator |
Combining rapid prototyping, custom server hosting, and close collaboration within our gaming community provides an exhilarating creative space to build games on our own terms.
Technological progress is fundamentally social. While online forums and open-source repositories are essential, nothing replaces the energy, spontaneous brainstorming, and long-lasting camaraderie of in-person developer gatherings.
I am actively organizing and hosting local technology meetups, systems architecture roundtables, and hackathons across my city (São Paulo metro area):
Creating welcoming, technically rigorous spaces for developers in my community is one of the most fulfilling ways I invest my time.
Sound and music have always been deeply intertwined with my programming journey. The same cognitive structures that govern clean software architecture—harmonic balance, temporal rhythm, modular signal routing, and frequency spectrum management—are central to musical composition.
In my idle time, I compose cyberpunk ambient soundscapes, retro game soundtracks, and electronic synthesizer tracks:
Writing is one of the most powerful tools for clarifying thought. When you force yourself to explain a complex low-level mechanism—such as ASLR delta base relocations, IPv6 extension header parsing, or VTIL instruction optimizations—you quickly expose any gaps in your own understanding.
I am committed to continuing this series of deep-dive architectural essays:
Technical mastery is not a destination; it is an ongoing journey fueled by relentless curiosity.
Whether I am engineering custom game servers and multiplayer netcode with my gaming collective, coordinating a local developer hackathon, tuning synthesizer filters for a new ambient track, or architecting a binary devirtualization harness in C++, the driving force remains the same: a passion for building, creating, and sharing with the world.