SKSaqlain Khan
A study in possibilityStay a little. There’s more inside.
Two circular rings at a right angle, rotating within their own planes.

Architect & software engineer

Ideas,
in motion.

Explore my work

Drag to look around

Form
01 / 244 rules · 24 permutations

Tap a rule. Change the form.

Make it your own
Combine the rules

One surface. A different outcome for every order.

ArchitectureFull-stack systemsApplicationsAI integrationScroll to explore
01 / A way of thinking

Fascinated by
possibility.

The moment before something exists.

I studied architecture because I wanted to make things. In Grasshopper and Rhino, I discovered that I didn’t have to draw every outcome. I could design the rules and let possibilities emerge.

Code became another medium for making ideas real. A form, a useful tool, a world of moving objects—each began with a question I wanted to follow.

01 / Form

Design the rules.

Canopy studies & procedural worlds

02 / Information

Make it usable.

ObjectTracer & engineering tools

03 / Reasoning

Ask for evidence.

SEBIRA & architectural intelligence

02 / Selected workBuilt, shipped & being explored

It started with
a question.

Some things are finished.
Some are still becoming.

01 / ObjectTracer

Live product

ObjectTracer.

One world.
Why so many maps?

I’ve always wondered what’s happening beyond what I can see. Aircraft above us. Ships between continents. Satellites overhead. Following them meant switching between separate worlds.

So I built ObjectTracer: one explorable globe. From the backend and real-time streams to the interface and 3D rendering, I kept building until those signals felt connected.

Independent product · full-stack design, development & deployment

01 / ObjectTracer Open ObjectTracer
Live globe Live product
ObjectTracer / Live globe Aircraft / ships / satellites / space
1.5kTotal users · Google Analytics
70k+Impressions · user-reported
40,000+Live-object rendering capacity

Then people I’d never met started using it.

Audience figures reported September 2026. Rendering capacity is separate from audience size.

The design problem

Not more data.
A clearer way to see it.

The interesting part was making different update rates and enormous changes in scale feel like one place. Pan the globe, follow an object, look closer—the system responds to what you’re looking at.

Follow a signal Interactive tracking study

Follow a signal

A continent of connections.

Sample traffic · not a live feed
A North America tracking illustration. The adjacent selector exposes each sample aircraft and ship.

From a signal to something you can follow.

01 / Collect
Go workers

Independent sources, independent clocks. Aircraft, orbital and maritime data enter one backend.

02 / Remember
Redis + PostgreSQL

Fast-changing positions stay separate from durable trails and object metadata.

03 / Deliver
WebSocket hub

A snapshot first. Then only the changes inside the visitor’s current viewport.

04 / Explore
React + Three.js

GPU instancing turns thousands of objects into an explorable spatial interface.

Explore the engineering

The details that make it work

Complexity underneath.
Clarity at the surface.

01 / Rendering
Thousands of objects.
A handful of draw paths.

GPU instancing shares geometry across aircraft categories. Reused transformation buffers keep the render loop lean. Selection works in screen space, using a spatial index at a distance and GPU color IDs up close.

InstancedMesh · screen-space picking · reusable buffers
02 / Streaming
The whole picture first.
Only the changes after.

A snapshot establishes the view. Delta messages update the objects that moved or disappeared. When the visitor pans or zooms, the viewport tells the server which part of the world matters.

Snapshot to deltas · viewport bounds · WebSocket hub
03 / Reliability
The invisible work
behind a fluid experience.

Reconnect handling, stale-object cleanup, bounded tile loading, and mobile memory fixes keep the experience usable beyond the ideal demo. Those decisions are part of the product, too.

Connection lifecycle · memory limits · progressive tiles

The challenge

Different data sources, refresh rates, and spatial scales have to feel like a single continuous experience. Rendering and network traffic both need to stay responsive.

What I built

A Go backend with independent data-source workers, Redis for live state, PostgreSQL for trails, and viewport-filtered WebSocket updates. React and Three.js translate those streams into an explorable world.

Beyond the code

I own the product from architecture and development through deployment, monitoring, analytics, search optimization, and continuous delivery on Railway and Vercel.

Project repository

02 / Knowledge into space · In development

Explore SEBIRA

SEBIRA.

Can a tool think
with an architect?

SEBIRA is my exploration of that question: an architectural second brain connecting AI, sourced knowledge, and deterministic geometry. I’m building the system—and learning where its limits are.

The model proposes.
Deterministic code decides.

GoRustKnowledge graphsAI integration

In progress: from a brief to a model and drawings.

SEBIRA recording Knowledge graph / zoom into the nodes
SEBIRA / From knowledge to geometry

“Where did this
dimension come from?”

Architectural passages enter with their source and licence recorded. The knowledge graph keeps claims connected to evidence.

Interactive system schematicSelect a node to look closer
Explore the reasoning pipeline

Inside SEBIRA / Architectural intent becomes an executable system

A line in a drawing.
A chain of reasons behind it.

A language model can suggest a dimension. An architectural system has to explain it, validate it, and keep that explanation attached as it becomes geometry.

  1. 01 / Ingestion
    Read with provenance.

    Record the source, licence, jurisdiction, and passage.

  2. 02 / Knowledge
    Connect the evidence.

    Build concepts and relations with evidence attached to each edge.

  3. 03 / Brief
    Understand the intent.

    Translate the request into a typed brief and surface what is missing.

  4. 04 / Decision
    Check the claim.

    Verify quotations and jurisdiction before accepting a candidate value.

  5. 05 / Operations
    Make it executable.

    Compose supported operations with cited dimensions.

  6. 06 / Geometry
    Let the kernel decide.

    Solve wall networks and execute geometry in Rust.

  7. 07 / Drawing
    Measure what was built.

    Derive dimensioned plans and sections from the geometry.

  8. 08 / Builder · In progress
    Close the loop.

    Bring the model and drawings into one connected design workspace.

113,152Architectural passages
165Licence-verified sources
489Backend tests with database

Project documentation snapshot.
Builder integration and drawing conventions remain in development.

An engineering decision
A native process boundary.
A more contained failure.

The Go service invokes the Rust kernel through JSON input and output. Keeping geometry in its own process isolates kernel panics from the API — a system-design choice driven by the behavior of the geometry engine.

The research question

Can a design system explain its decisions in architectural terms, connect each proposed dimension to its evidence, and turn those decisions into executable geometry?

The system

A Go API, PostgreSQL knowledge store, an OpenAI-compatible model endpoint, and a Rust geometry engine. The pipeline connects source passages to decisions, operations, geometry, and derived drawings.

Where it stands

An active research and engineering project. Integrating the builder and completing drawing conventions remain work in progress. Current work uses existing models; custom model training is a future research direction.

Read the project overview

03 / Rules into form · Experiment

Play the original

Rules into possibilities.

How many forms
can one rule make?

Instead of drawing one answer, I wanted to design the rules that produce many. This Wave Function Collapse experiment turns that curiosity into a small, playable world.

Wave Function CollapseProcedural generationDesign exploration
Procedural generator recording Parameters / terrain / possibilities
Try a small adjacency study
Interactive portfolio companionSeed 024

A new arrangement.
The same connection rules.

A tile-adjacency illustration made for this portfolio. Open the original for the full WFC experiment.

Form studies & engineering tools

The same curiosity.
Different scales.

BioInspired Canopy: an undulating structure in a misty wooded landscape
04 / BioInspired Canopy2022 · Independent study

Architecture / visual computation

From image to inhabitable form.

An exploration of image-based form generation. Python and OpenCV interpret visual references; Grasshopper and Rhino turn the resulting relationships into a variable canopy.

Python / OpenCVGrasshopperRhino
Inside the design process Image → rules → spatial variations

Could a two-dimensional reference become a family of inhabitable forms?

This 2022 independent study explored nature-inspired structure in place of a conventional truss. I connected Python and OpenCV image interpretation to GHPython, Grasshopper and Rhino, using parameters to explore multiple canopy configurations.

  1. 01 / Interpret

    Start with a reference.

    Combine biological image references, locate points in three-dimensional space, then interpret their relationships as lines.

  2. 02 / Construct

    Give the lines a surface.

    Form surfaces from the linework and connect their points into a mesh.

  3. 03 / Vary

    Design more than one answer.

    Introduce variability, retain different permutations, and expose those configurations through sliders.

  4. 04 / Refine

    Inspect the result.

    Check for disconnected regions and problematic mesh elements before reviewing the form spatially.

Original Grasshopper definition for the canopy study
Inside the rule system · original Grasshopper definition
Interior view beneath the generated canopy
From a definition to the experience beneath the canopy

A computational design exploration, not a built project or a validated structural-performance study.

Red Voronoi mesh with a branching cellular structure
05 / Voronoi Fracture2022 · Independent study

Computational geometry / material expression

Structure in the spaces between.

A mesh-subtraction study that uses Voronoi logic to explore cellular structure, porosity, and light. Built in Grasshopper and Rhino; rendered in Cinema 4D.

Mesh operationsParametric designCinema 4D
The geometric idea Volume → subtraction → skeleton

What if the empty space defined the structure?

A 2022 independent mesh study exploring an alternative to a conventional truss within a cube. The geometry begins with a volume; a Voronoi-based cellular field removes material and leaves a branching skeleton.

  1. 01 / Define

    Solid and void.

    Use Grasshopper and Rhino to establish the bounding form and the cellular subtraction geometry.

  2. 02 / Subtract

    Keep the spaces between.

    Mesh subtraction reveals an interconnected form. Porosity becomes part of the design language.

  3. 03 / Read

    Study it through light.

    Cinema 4D renders make the surface, openings and vivid red material easier to read.

Computational geometry and material expression. The render explores a structural idea; it does not claim engineering validation.

06

BIM / production automation

Revit vendor drawing automation

C# / Revit API / APS
Revit model used in the vendor drawing automation project

A design change shouldn’t restart days of drawing work.

The bottleneck

Vendor drawings translate a model into information fabrication teams can use. Repeated manual work makes each revision slower to deliver.

What I implemented

C# and the Revit API connect model information to repeatable drawing generation, with APS supporting cloud workflows. I worked with architects and fabrication specialists to connect software rules to production requirements.

Why it matters

The aim is less repetitive preparation and faster responses to changes—freeing time for design decisions while keeping fabrication information consistent.

2023 · Revit, C#, PowerShell, APS and web interfaces. Implementation details shown at a public portfolio level.

07

Cloud / event-driven engineering

BIM 360 file & folder alerts

ASP.NET / Webhooks / Azure
BIM 360 data-management application and notification interface

Let the change find the person.

The problem

On a shared engineering project, people shouldn’t need to keep reopening folders to discover whether a file has changed.

The system

A management interface lets users configure hooks for BIM 360 / APS file events. An ASP.NET Core backend receives those events and connects them to notification workflows, with email and SMS choices in the interface.

  1. File changes
  2. Webhook event
  3. Backend handling
  4. User notification

From interface to deployment

I connected the management UI, APIs and event handling, and deployed the application on Azure. The work made background changes visible without constant manual checking.

2023 · ASP.NET Core, APS / BIM 360 APIs, JavaScript, Node.js and Azure.

08

Model intelligence / three connected studies

Making BIM data readable

APS / Power BI / Node.js

A model becomes useful when you can ask it a precise question.

Power BI analytics integrated with an APS model viewer

2024 / Visualization

What does this element tell us?

I integrated Power BI with an APS / BIM 360 model-viewing platform. Users can inspect Revit models in the browser and explore component information alongside analytics.

The connection between spatial selection and data makes a dashboard part of the model-reading experience.

Power BI · APS Viewer · web APIs · Azure

BIM model version comparison with an ACC hierarchy and model changes

2025 / Version comparison

What changed since the last model?

A Node.js application uses the Model Properties API to compare two versions. Added, removed and updated elements are visualized alongside the BIM 360 / ACC project hierarchy.

The study examines both geometry and property changes, turning a revision into something a reviewer can inspect in the browser.

Node.js · Model Properties API · BIM 360 / ACC

Diagram from the Autodesk model-data extraction and quantity-takeoff study

2025 / API investigation

Which data path fits the question?

I compared Data Model, Model Derivative and Data Exchange approaches for element extraction and quantity takeoff. The prototypes cover authentication, hub selection and inspecting element information.

The focus was choosing between targeted element queries, broader model processing and exchanging selected data—not treating every information task as the same API call.

MERN stack · APS · Azure. A record of the project investigation, not a current API pricing or compatibility guide.

03 / The next questionArchitecture / intelligence

Design computation / Architectural intelligence

What if a model could
reason spatially?

Buildings hold more than geometry. They hold decisions, constraints, and human experience.

I want to study how AI can connect that knowledge across drawings, models, and language—and explain its design decisions. A direction I’m pursuing through SEBIRA and future doctoral research.

Let’s talk about research
01 / Representation

How do we encode
architectural knowledge?

Visual computing, shape-based systems, and relationships across representations.

02 / Reasoning

How does a system
justify a design decision?

Evidence, constraints, agentic workflows, and human–machine collaboration.

03 / Making

How does intelligence
become buildable?

Parametric geometry, engineering automation, and a path from intent to output.

My point of view

Not just the shape.
The reasons behind it.

04 / The person behind the workBangalore, India

So much left
to make.

I’m Saqlain. An architect, a software engineer, and still a student of things I don’t understand yet.

My foundation is architecture at NIT Patna. Today I build full-stack products, engineering applications and AI-connected design tools.

There are systems I haven’t built and entire fields I know almost nothing about. That makes the future exciting.

Download my résumé PDF
The questions I keep following
“Most of the things I’ve built began this way. Not with a technology. With a question.”

An empty page before the first line. A piece of geometry before it becomes a space. An idea before anyone knows whether it will work. I’ve always been drawn to that moment of possibility.

Experimenting with Grasshopper and Rhino changed how I made things. Change a parameter or a relationship, and the same idea could become something entirely different. Python helped me turn images into geometry. Automation helped me remove repetitive work. Software gave those questions somewhere else to go.

ObjectTracer taught me something about letting an idea into the world. Getting it to work meant following one problem into the next. Then people I’d never met began using it. Something that started on my computer had become useful to someone else.

SEBIRA begins with a different question. Buildings carry decisions, constraints and experience. Can a system move from language to geometry and still explain why? I don’t know how far that idea can go. That’s part of why I’m building it.

That’s what Starman Odyssey means to me: someone who keeps looking toward the stars, willing to follow an idea without knowing exactly where it will lead. There is so much left to learn—and a very long way still to go.

Current role / December 2025 — present

Employer · since July 2023
Client-side assignment

Software Development Engineer 1

AtkinsRéalis · working on Intel projects

Building full-stack systems, desktop applications, and AI integrations for engineering workflows. Employed by AtkinsRéalis; working client-side on Intel projects.

Full-stack developmentEngineering applicationsAI integration

Architecture / June — December 2022

Architectural Intern

Gensler · Bangalore

Workplace and hospitality projects, alongside computational design and automation with Rhino, Grasshopper, Revit, and Dynamo.

Computational designProcedural geometryDesign workflows
The path through AtkinsRéalis
Jul 2023 — Feb 2024

Software Engineer Trainee

Revit API and C# workflow automation; approximately 70% reduction in manual effort reported in my résumé.

Mar 2024 — Feb 2025

Graduate Software Engineer

React, Node.js, APS, BIM 360, event-driven services, and engineering visualization.

Mar — Nov 2025

Assistant Software Engineer

C#, WPF, MVVM, SQL Server, asynchronous programming, and enterprise application performance.

Design & computation

Rhino · Grasshopper · Dynamo
Revit API · APS · BIM workflows

Systems & intelligence

Go · Rust · C# · Python · TypeScript
React · LLM integration · RAG

Shipping & operating

Docker · Azure · Railway · Vercel
CI/CD · GitHub Actions · Monitoring

Foundation

B.Arch · NIT Patna
2018–2023 · GPA 3.66 / 4.0

Have a question worth exploring?

Let’s make
something meaningful.

mdk.ug18.ar@nitp.ac.in
ElsewhereLinkedIn GitHub ObjectTracer