@huncikoma

Devlog#13 Finally, I finished the project, it is working, I created an install and a run batch file, and it is working, EVERYTHING!!! here a demonstration video (Sorry for the quality i have to shrinf from 201mb to 49mb) in the max level i’m getting 2.2 fps with a 5070!!!

Devlog#12 Finally!!! I finished the main code, however I must do some bugfixes, and write a batch file to automaticly download python libaries, extensions , drivers to work. In the next devlog I can finally show you simulation footage.

Devlog#11 In this section I worked a lot, I made the render section and the dynamic resolution scaling (auto mode).

Devlog#10 Today I almost finished the Application part, doing some bug fixes, collecting the requirements, and I also did the rotating camera function and the orbit function as well

Devlog#9 Today I made the buffers and the screen size types to work but I can’t try it yet. because I has to finish the code

Devlog #8 I continued the aplication part, I made the screenshot option, this project is huge and I am very excited about it.

Devlog#7 Finally I’m ready with the quality part, and I am working now on the Apllication and the Cuda drivers, In this section the Ai hellped me with the Cuda accelaration part because as I mentioned in my devlogs I didn’t work with Cuda before and I’m learning in the meantime with the help of Ai.

Devlog#6 Today I worked around the graphics section more and I made the windows options: Fulscreen, windowed etc…

Devlog #5 In this part I fixed a lot of bugs around the cuda and the kernel section, I searched the compatible Cuda acceleration drivers.

I made the Quallity settings for the reendering, I swear the 8K will be brutal.

Devlog #3 — Post-processing and cameraRaw
output from the renderer is HDR — values way above 1.0 around the disk.

Devlog #2 — The render kernel Every pixel is one GPU
thread, each tracing a photon backwards from the camera.

Devlog #1: Black hole raytracer, the GPU side New
project. This time it’s a real-time black hole renderer, including
gravitational lensing and the accretion disk. It’s in Python, which
feels familiar after working on the ISS tracker.The
main idea is to shoot a ray for every pixel and bend it according to
the Schwarzschild geodesic equation as it passes the black hole.

Devlog #10 — Crew, startup & it’s doneLast pieces today.Crew
section first. Pulls from the Open Notify API — who’s on the ISS right
now. Had to route it through a CORS proxy because the API is http-only
and browsers block that from an https page. Filters for ISS crew
specifically, falls back to everyone in space if the filter comes up
empty. If the API dies, shows a graceful “unavailable” message instead
of breaking.Then the startup section — the part
that boots everything. Load saved observer location, fetch TLE, fetch
crew, then the intervals: tick() every second, orbit path refresh every
minute, fresh TLE every 2 hours, crew every 6 hours. Everything on its
own schedule.Finally made it actually easy to run.
Wrote a small Python server file that spins up a local webserver — this
is where my Python comfort zone finally got to shine in this project.
Plus a start.bat that launches the server and opens the app in the
browser in one double-click. And a README so anyone can figure out how
to run it.That’s it. The tracker is done. Live
position, 3D globe, pass predictions, crew list, one-click startup.
Started this barely knowing what a div was.

Devlog #9 — Pass predictionThe part I was most scared of. Also the coolest.computePasses()
steps through the next 6 days in 30-second jumps, calculates the ISS
position at each step, and converts it to look angles from your
location. Elevation above 10° = pass starts. Drops below = pass ends.The
visibility check is the fun part. You can only see the ISS with your
own eyes if three things line up: it’s above 10°, the sun is 6°+ below
your horizon , but the ISS up there is still catching
sunlight. Basically a sunlit object against a dark sky. That’s what
you’re actually seeing.Also finished the
geolocation button, the reverse geocoding for your city name, and the
pass table — time, duration, max elevation, compass direction. Visible
passes get an orange dot.Deepest I’ve been in over my head this whole project. But piece by piece, it makes sense now.

Devlog #8 — TLE age, observer location & localStorageShort but important session.First,
finished off the tick() function. Added TLE age display — shows how old
the orbital data is. Under an hour it shows minutes, over an hour it
shows decimal hours. Small detail but useful, stale TLE data means
inaccurate position.Then observer location. This
took a bit of thinking. The app needs to know where you are to predict
ISS passes — so setObserver() takes lat/lng, validates it (no infinite
values, lat within ±90, lng within ±180), converts to radians for the
math, and stores it.The localStorage part was new
territory for me. Never used it before. Basically the browser remembers
your location between sessions — so next time you open the app it loads
your saved coordinates automatically via loadObserver(). One line to
save, one line to load, JSON in between. Actually really simple once I
understood it.The observer marker gets placed on
the globe too — same system as the ISS marker but sits almost on the
surface (altFrac: 0.005).Input fields update to
show the saved coordinates. The location display shows hemisphere format
— 47.50° N, 19.04° E style — then “loading…” underneath while it
reverse geocodes the place name.Coordinates,
radians, localStorage, marker placement — a lot of small things that all
had to connect correctly. Felt good when it clicked.

Devlog #7 — Camera, live updates & the tick loopThis session was the one where it started actually feeling alive.Camera
controls first. Three modes — follow, rotate, free. “Follow” mode
smoothly pans the globe to the ISS position every 2.4 seconds with a
900ms animation. Feels really clean, like the camera is actually
tracking something. “Rotate” just spins the globe on its own. “Free” is
hands-off, user controls everything. Also wired up the day/night texture
toggle — one click switches between the blue marble and the night
lights texture.Found a bug: setStatus() is missing
a space — “led” + cls produces “ledlive” instead of “led live”. The LED
will never change color because the class name is wrong. One character
fix.Then the tick() function. This is the
heartbeat of the whole app. Runs on an interval, calls stateAt(now),
updates the marker position, updates all the telemetry readouts — lat,
lng, altitude, speed, orbital period, illumination. Everything live.

Devlog #6 — Markers, orbit track & resizeShort session today but got a few important things done.Set
the globe’s starting view — looking down at lat: 20, lng: 0 from
altitude 2.4. Basically a nice “overview of Earth” angle when the page
loads. Auto-rotate speed set to 0.45, slow and smooth. Small detail but
it makes the whole thing feel alive even before any data loads.Then
the markers. Two functions — makeIssEl() and makeObsEl() — each just
creates a div with the right CSS class and inner HTML. The ISS gets the
orange ring, the observer gets a “You” label. Simple.Found
two HTML typos in there while writing this. makeIssEl() has </div
missing the closing >. makeObsEl() is missing the opening < on the
dot div — ‘div class=“dot”>’ instead of ‘’.
Both will silently break the markers in the browser. Need to fix those.The
orbit track was interesting. It loops from -25 minutes to +70 minutes
around now, samples a position every 1.5 minutes, builds a path array.
So you see where the ISS came from and where it’s going. Past 25
minutes, future 70. Felt like a very “Python” approach — just loop,
collect, feed into the renderer.Also wired up
resize handling. Globe redraws to fill its container whenever the window
size changes. One listener, one function.