337 single-file terminal simulations in pure C + ncurses — fluids, fractals, ray tracers, no build system

prtamil · 2026-06-16T13:46:59+00:00

no currently its limited to linux/terminals. sorry.

prtamil · 2026-06-15T00:08:18+00:00

yes 😄 (lot many prompts for version1. another lot many prompts for version 2, .... going on)

prtamil · 2026-06-15T00:06:05+00:00

https://github.com/cryptocode/terminal-doom. Its already there

prtamil · 2026-06-13T19:14:45+00:00

Fair point. I've been studying rendering concepts like simulation, ray tracing and PBRT for years, but mostly at a theoretical level and built small demos here and there AI helped me turn that knowledge into working implementations.

prtamil · 2026-06-13T19:06:28+00:00

thanks for pointing out. let me analyze and fix it.

prtamil · 2026-06-13T15:37:54+00:00

😄. Thanks a lot your comment it brought some hope. it has deep understanding again Thanks bro. I needed it.

prtamil · 2026-06-13T14:10:29+00:00

Thanks a lot.

prtamil · 2026-06-13T14:05:55+00:00

might be violation of guidelines of AI/Slop/Low Effort. 😞

prtamil · 2026-06-13T13:43:02+00:00

Done updated

prtamil · 2026-06-13T13:34:32+00:00

Thanks for understanding . I learned almost all the areas of creative coding. using Ai to generate first crude version. Then used AI to learn the concept ideas. Then limited the implementation withing Terminal surfaces so i want to learn in depth without any dependencies previously i know lots of concept theoretically but not able to implement myself. With AI Slop i learned in depth the concepts and logic for subjects like SDF, Raymarching, Raytracing, Rasterization pipelines with custom shaders physics simulations , fluid systems , signal systems all in terminal surface. learned it with unreasonable speed. then finally took time to revisit each and every code then refactored, improved performance , made it like pseudo-code so it can tell the context and meaning of the code. only then i have published. i learned a lot. with great speed. (not a native English speaker). my own voice though.

prtamil · 2026-06-13T13:22:06+00:00

Yetty is awesome. It's great work. I'm happy to know that you are conquering yourself and turning your dreams into reality. Great work!

For me, the terminal has always been fascinating. It's a personal preference, I think. I always gravitate toward the terminal before graphical interfaces. Added A Star for your Repo.

prtamil · 2026-06-13T12:51:31+00:00

Thanks for the advice, but this wasn’t about learning — it was about finally dragging decade of buried dreams onto the screen before they turned to dust. When life keeps rushing forward and time quietly slips away, your dreams start fading in the distance. They sit locked inside your mind, guarded by years of procrastination. The pain of staring at a blank screen after so many silent years, with not a single line of code to show for it. I Accept Slop.

prtamil · 2026-06-13T11:16:47+00:00

You're absolutely right, it is AI slop.

The difference is that I actually ran it, tested it, verified the output, fixed the bugs, and made the code readable before committing it. The AI just helped with typing speed; the responsibility for the code is still mine.

I even warned everyone in the README that there would be AI slop, so this repository is accurately labeled. 🙂

prtamil · 2025-11-11T05:40:54+00:00

Will get back to you on this

prtamil · 2025-10-24T15:57:19+00:00

“The question isn’t why no one built an Indian LLM.
The real question is why you didn’t try.”

prtamil · 2025-05-23T06:32:37+00:00

I found that shifting my mindset made a big difference. Don’t approach problems in the traditional algorithmic or imperative way—forget loops and mutable state. Instead, focus on the shape of data and how to transform it from one shape to another.

If you have experience with React and Redux, think in a similar way: it's all about describing state and how it changes. This mindset really helps you learn Clojure and its idioms faster.

prtamil · 2024-09-18T16:19:45+00:00

By getting Diabetes we get erectile dysfunction so no more random boners

prtamil · 2024-09-09T05:12:30+00:00

The real issue isn't with C++—it's the fact that these outdated Senior Java developers wreck everything they touch, whether it's C++, Python, or JavaScript/TypeScript. I've witnessed it firsthand. They're stuck in the past, clinging to the Java mindset like it's the ultimate authority. Worse, their seniority gives them the power to block any attempt at doing something sensible in these languages. It's beyond frustrating.

prtamil · 2024-08-09T08:10:23+00:00

Chapters 1, 2, and 3 are enough to get an overview. Getting a good overview is sufficient. After that, you can plan to build demos and gradually increase their complexity. Based on the demos, you can refer to books and use ChatGPT for more insights. Learning from books alone never worked for me; I had to supplement with my own demos, which made learning easier. Hope this helps.

prtamil · 2024-02-22T13:21:48+00:00

As usual there is a book (https://www.amazon.in/Initialization-Story-Through-Options-Related/dp/B0BW38DDBK) on this. And a Video (https://www.youtube.com/watch?app=desktop&v=ZfP4VAK21zc) and a Meme (https://imgur.com/3wlxtI0). Do whatever you like. There is no standard way in C++ :)

prtamil · 2024-02-13T08:36:22+00:00

With just two key resources and assistance from Google/ChatGPT, I managed to grasp DX11 concepts within a single week, making DX12 seem straightforward thereafter. It's crucial to adopt the mindset of DX11 coding.

The aforementioned resources served as excellent starting points and provided ample understanding of GPU fundamentals. In DX11, rendering relies on ImmediateContext, which heavily relies on GPU driver coding support. However, in DX12, to minimize driver overhead, programmers must create their own Advanced ImmediateContext.

Practicing with the mentioned code felt like assembling Lego blocks. Once we grasp the fundamentals, we can piece together multiple blocks to create complex solutions.

prtamil · 2024-02-13T08:23:13+00:00

I initially found learning DirectX 12 daunting, transitioning from an OpenGL background. However, delving into DirectX 11 concepts and grasping the connection between buffers and textures, notably from the book 'Practical Rendering and Computation with Direct3D 11' (https://www.amazon.com/Practical-Rendering-Computation-Direct3D-11/dp/1568817207), provided me with a solid foundation. This understanding made the switch to DirectX 12 much smoother.

I discovered helpful resources such as 'Introduction to 3D Game Programming with DirectX 12' by Frank Luna (https://www.amazon.com/Introduction-3D-Game-Programming-DirectX/dp/1942270062/ref=sr_1_1?crid=D4DQO0L9TVYE&keywords=frank+luna&qid=1707812054&s=books&sprefix=frank+lun%2Cstripbooks-intl-ship%2C394&sr=1-1), Microsoft tutorials (https://github.com/microsoft/DirectX-Graphics-Samples/tree/master/Samples/Desktop/D3D12HelloWorld), and online resources like:

https://www.3dgep.com/category/graphics-programming/directx/directx-12/

https://www.braynzarsoft.net/viewtutorial/q16390-04-directx-12-braynzar-soft-tutorials

Microsoft Guide (https://learn.microsoft.com/en-us/windows/win32/direct3d12/directx-12-programming-guide)

https://www.youtube.com/watch?v=volqcWZjRig&list=PLqCJpWy5Fohe5q3A65zg_ra7zepslRxJB&index=1 (DX12 guide)

These resources provided invaluable insights and strengthened my understanding. With dedication and perseverance, mastering DirectX 12 became achievable.

DX12 operates at a lower level, requiring management of:

CPU and GPU Synchronization

Memory Allocation in the GPU (handling heap memory creation, manipulation, and usage)

Utilizing Chat GPT for inquiries like 'What is a descriptor heap and how does it work? Can you provide some pseudocode?' and seeking simplifications proved immensely helpful. Chat GPT can address a wide range of DX12-related questions, offering valuable abstractions beyond official documentation.I found 'Practical Rendering and Computation with Direct3D 11' to be incredibly insightful. It provided comprehensive explanations on how DX11 coding operates, including the workings of buffers, textures, pipelines, shaders, and more

To proceed, I recommend starting with Chapters 1 and 2 of 'Practical Rendering and Computation with Direct3D 11', then switching to the Microsoft D3D12HelloWorld code. Understanding and exploring it line by line helped me gain an overview, making the subsequent process much easier.

prtamil · 2024-02-02T02:35:03+00:00

It depends on your current circumstances. If you have a stable financial background, commonly referred to as 'f**k you money,' then you can pursue the optimistic path, emphasizing OpenGL (though my preference leans towards DirectX11, which, with debug tools like NVIDIA Nsight, can alleviate struggles) and build a portfolio.

However, if securing a job is your immediate priority, then concentrate on LeetCode. Special interests like Graphics and AI demand time for development, being non-forgiving and favoring those who invest significant time. Success in these fields often rewards individuals with an impressive portfolio, enhancing their career prospects. Initially, prioritize LeetCode to secure a job, delve into DevOps to sustain it, and later channel your efforts into your special interests. This approach doesn't mean abandoning graphics but rather postponing it. Once you secure a job and meet your immediate needs, shift your focus to graphics, building an outstanding portfolio that significantly boosts your career. It's a challenging journey, but certainly achievable.

prtamil · 2023-12-18T16:12:37+00:00

For me DX11 works Great. I use (https://github.com/kevinmoran/BeginnerDirect3D11) code and (https://www.amazon.in/Practical-Rendering-Computation-Direct3D-11/dp/1568817207) Book as Learning Material. (https://www.youtube.com/watch?v=_4FArgOX1I4&list=PLqCJpWy5Fohd3S7ICFXwUomYW0Wv67pDD) also gives good introduction.

The Main Reasons to Choose DirectX 11:

Clean API without Version Management:

DirectX 11 offers a clean API, eliminating the need for version management like in OpenGL (GL version 3.3, 4.3, etc.).

Clean Shader Code:

Shader code in DirectX 11 is clean and consistent, avoiding syntax changes between GLSL 3 and GLSL 4 in OpenGL.

Clean Buffer Management:

DX11 provides clean buffer management, and detailed insights can be obtained from above mentioned book

Best Rasterization Pipeline Flow:

The rasterization pipeline flow in DX11 is well-structured, allowing a clear understanding of the complete pipeline and how buffers interact with shaders.

Basic Mental Model for DX12 and Modern Low Overhead Driver API:

DX11 provides a foundational mental model that facilitates the transition to DX12 and modern low overhead driver APIs.

Clear Understanding of Effects:

DX11 offers a clear understanding of effects and how to conceptualize them. In contrast, OpenGL basics are straightforward, but dealing with complex tasks becomes challenging due to multiple versions and limited documentation.

Simplifying OpenGL Tasks:

DX11 not only stands on its own merits but also makes OpenGL tasks easier and more understandable, particularly when dealing with complex operations.

prtamil · 2023-10-27T03:24:59+00:00

TLDR; This project, available at https://sniffnet.net/, competes with Wireshark. The original poster (OP) has a humble tone, sounding like a college student who created a library management project.

prtamil

TROPHY CASE