moofy.org

Introducing FINDS: the Fish INteraction and Dynamics Simulation Library

Mon, 31 Aug 2026 15:00:14 +0000

I’ve had the pleasant experience of working in a fluid mechanics laboratory for the past two-and-a-half months, and this lab was primarily focused on schooling behavior of fish due to hydrodynamic interactions. I had originally intended to do something a bit more fundamental in fluid mechanics so that I could learn some fluid physics while working, but interestingly, their concern on fish dynamics is actually far more of a particle simulation problem.

The issue they tasked me with solving is fairly simple and purely computational: real fish schools are far larger than they could simulate using straightforward, brute-force calculations. They were interested in modelling only passive hydrodynamic interactions between fish (so ignoring behavioral factors or active effects like vortical wake), but any simulation system consisting of \(N\) point-masses (or similar) where each point-mass effects each other point mass requires the calculation of \(N^2\) interactions per time-step. This is, by definition, the \(N\)-body problem as seen in countless situations in computational physics, and as anybody who has ever dealt with this problem will tell you, it is the greatest bottleneck performing any computational research in particle-based systems. In particular, in this lab, they couldn’t get much farther than tens of thousands of swimmers: numbers around fifty thousand fish were considered quite high for simulation, and most of the research in the lab focused on less then fifty (often only two). This is a massive problem for research into this field, however, as real fish schools have been found to contain hundreds of millions of swimmers, thus leaving a massive gap in research as group sizes in the tens of thousands are puny compared to the hundreds of millions.

Therefore, I was tasked with creating a simulation program efficient enough to handle hundreds of millions of swimmers by using standard computational particle dynamics techniques, such as implementing the Barnes-Hut algorithm, the Fast Multipole Method, and using parallel and/or distributed computing. This led to the creation of FINDS, a C library for performing fast simulation of large schools.

This library brings the computation time for the derivative of a system down from a time complexity of \(O(N^2)\) to \(O(N \log N)\) and \(O(N)\) using the Barnes-Hut approximation and the Fast Multipole Method respectively, and this translates into a difference in computation time from hours or days per computation to seconds at scales at or above \(10^5\) fish (see the figure below).

FINDS by example

The way that FINDS works is incredibly simple, and I’ll use the example imploding_sphere.c.

First, we can load in all of FINDS with the header <finds/finds.h>, but each individual module can be loaded in manually. The beginning system configuration is manually defined by the user, and this can be done by setting the distribution, orientation, and constant options to define standard schools or by manually setting the parameters for each fish in the system.

In this case, we want to produce a sphere that implodes upon itself, i.e., what we can see in the figure below.

To do this, we first need to set a spherical distribution (a fibonacci sphere) with the following code:

distribution_options_t dist_opts = {0};
dist_opts.type = DISTRIBUTION_SPHERE;
dist_opts.radius = RADII;
dist_opts.spacing = SPACING;

Then, we set the orientation of the fish to all face the origin:

orientation_options_t ori_opts = {0};
ori_opts.type = ORIENTATION_RADIAL_INWARD;

And then, lastly, we set the fish to all be uniform in length and volumetric flow rate:

constant_options_t const_opts = {0};
const_opts.random_length_selection = false;
const_opts.uniform_length = 1.0;
const_opts.random_volumetric_flow_selection = false;
const_opts.uniform_sigma = 4 * M_PI;

Then, we build the overall initial system:

fish_system_t *system = fish_system_generate(
    dist_opts, ori_opts, const_opts, true);
if (!system)
    return EXIT_FAILURE;

Now, all that is necessary is determining how we compute the derivative of each state and how we will integrate this derivative to compute each next state. Per the derivative scaling figure above, it would be ideal to compute the derivative using the Barnes-Hut algorithm with a high approximation ratio, \(\theta=1.0\), as the initial overhead is considerably low.

derivative_computation_opts_t dc_opts = {0};
dc_opts.method = BARNES_HUT;
dc_opts.approximation_threshold = 1.0;
dc_opts.regularize = true;
dc_opts.regularization_epsilon = 1E-6;

Then, for the integrator, we can pick a basic non-adaptive integrator as this is a fairly stable system (up until the point of implosion, at which it becomes extremely unstable, making regularization would be necessary):

integration_opts_t int_opts = {0};
int_opts.method = RUNGE_KUTTA_4;
int_opts.eval_time_step = 1.0;
int_opts.end_time = 100;
int_opts.print_time_progression = true;

With all of that setup, we can perform the simulation, and this returns the filename of the produced trajectory data in HDF5 format:

char output_folder_name[BUFFER_SIZE];
char output_filename[DOUBLE_BUFFER_SIZE];

errcode = perform_simulation(
    system, dc_opts, int_opts,
    output_filename, output_folder_name,
    BUFFER_SIZE, DOUBLE_BUFFER_SIZE, false);
if (errcode != ERR_OK) {
    puts("Error occurred! Dataset is likely corrupted.");
    goto jmp_system;
}

And after performing a simulation, we can run the post-processing modules on the produced dataset with make analyze file={ouptut_filename}, and this produces analysis figures like a plot of the mean radial distance, animations, etc.

Locating FINDS and the Manuscript Pre-print

For more in-depth information, the FINDS documentation can be found online (Online Link) and the pre-print manuscript describing FINDS can also be found here (PDF).

Introducing the Experimentalis Library

Sat, 24 Jan 2026 23:26:31 +0000

Flashback to last year. I took a physics laboratory course that would routinely hand me new functions for fitting nearly every week, and with each new week, I continued to build a growing, monstrous Python file containing each of these analysis routines. I called this file common.py, and as the file grew, it became incredibly cumbersome and annoying to try and manage everything, so I had to start going back into the file and generalizing everything with classes and generics and such. When this first lab class ended, I thought that I was done with having to bother with these for good, but following the end of the class, my immediate next lab course required the same work, so I started again with a fresh common.py that seemed to grow even larger and faster than the previous one did. At that point, I got fed up, and just did a little Sphinx magic to finally document and formalize this franken-file of jumbled up functions into a proper library for data analysis called Experimentalis.

The way that the library works is very, very simple. It’s based on two key data types: datasets and models, and the whole point is building a big repository of various models to fit to various models to approximate parameters.

Some examples are included with the project’s GitHub repository, but I’ll illustrate two of them here as well. Imagine I have some noisy dataset that I believe matches some known form (which can be an analytical function or some differential equation) such as the case of a damped harmonic oscillator:

Now, assuming I have some arrays t, y, dx, and dy containing the time values, the amplitude-values, and the uncertainty in the time-values for each measurement, I can build a Dataset object to store this full dataset:

dataset = Dataset(
    x=t,
    y=y,
    dx=dx,
    dy=dy
)

Then, I can make some guesses on this dataset based on first principles or background knowledge or etc. I already know that this dataset should be the result of a damped harmonic oscillator, so I’ll be fitting a model of the form

\[f(t) = A \exp(-t/\tau) \cos(2 \pi f t + \phi)\]

where \(A\) is the amplitude, \(\tau\) is the time/damping constant, \(f\) is the frequency of oscillation, and \(\phi\) is the phase. I could do some simple mathematical analysis or simply guess to develop some simple guesses for where each parameter realistically should be, and in this case, our guesses can safely end up being \(A = 0.8, \tau = 0.1, f = 1,\) and \(\phi = 0\). From that, we can make our model:

model = DampedHarmonicModel(
    amplitude = 0.8,
    time_constant = 0.1,
    frequency = 1.0,
    phase = 0
)

and now, all we need to do is just fit the model to the data, and see what happens:

result = autofit(dataset, model, graphing_options=g_opts)
print_results(model, result, units=['m', 'Ns/m', 'Hz', 'rad'])

And the output of this yields \(A = 1.0, \tau = 0.15, f = 1.2,\) and \(\phi = 0.3\) for \(\chi^2 = 1.0\), and we get the following plot:

display(result.autofit_graph)

showing that this fit really did work as-intended, and the parameters we obtained are reasonable.

Now, what is incredibly important to keep in mind here is that fundamentally, this data is just a one-dimensional series. This means that we can very easily make new models for fitting all kinds of one-dimensional series, such as time-series, and a very classic example of this is in stock market prediction. A fairly trivial model for stock markets, in particular, is Geometric Brownian Motion from Stochastic Calculus, and similarly to before, we can also use this library to fit a GBM model to real stock data. Once again, presume we have some stock data on Microsoft as loaded in this form:

prices = df[stock].values
dates = np.arange(len(prices))

returns = np.diff(prices) / prices[:-1]
noise_std = np.std(returns)

dataset = Dataset(
    x=dates,
    y=prices,
    dx=np.full_like(dates,  2/24),
    dy=np.full_like(prices, noise_std)  # small assumed measurement uncertainty
)

which looks like the following:

We can then build a simple GBM based on assuming 2% volatility (\(\sigma=0.02\)) and 0.11% drift (\(\mu=0.0011\)):

model = GBM(
    initial_value = prices[0],
    drift = 1.1e-3,
    drift_bounds = (0,0.1),
    volatility = 2e-2,
    volatility_bounds = (0,1)
)

Then, we can just let it run buck-wild on this data:

result = autofit(dataset, model, graphing_options=g_opts)
print_results(model, result)

and this actually won’t change the model parameters we gave it due to the fact that its a stochastic model (so there are local minima essentially everywhere, making curve_fit useless), but it can give some really interesting potential fits:

However, each at a substantial price: \(\chi^2 > 5 \times 10^7\). Again, though, this is to be expected, as this is a very naive model, so it is entirely to-be-expected that it wouldn’t work.

My Trip to New England

Sat, 24 Jan 2026 13:22:17 +0000

I went to New England last summer, took a whole bunch of pictures, then I started this article and proceeded to not finish it for four months straight. I feel as though it is more than high time that I went back through here and showed off some of the great things I got to see.

I took the trip in mid-July, a few weeks before going back to school for the year. At the time, I was finishing the Autobiography of Malcolm X, and the last time I had been to Boston was my Senior year of high school, so I knew I really wanted to get a good look around both Manhattan and Boston, particularly to visit Harlem and a few big-name universities.

So, I took a six-hour flight to Newark, then ended up hoteled in Jersey City, NJ, right outside of Manhattan. Right outside my hotel, there was this little gang of homeless street-cats just chilling out near a railway line, and I thought that they looked super cool, so I took plenty of pictures of the little guys. Check it out:

If you want to see all of the cat pictures, you can see them here.

Of course, I was in New Jersey, after all, so there are plenty of non-feline flicks from there. What was most interesting to me was the ethnic-Indian neighborhood called “Little India” near where I was staying.

It had this particular street called “India Square” that had all sorts of cool restaurants and shops. I even had lunch at one of the places, and it was pretty great.

I also just generally walked around New Jersey, and that was fun. For example, I got to see Central Avenue:

Then, once New Jersey was all said-and-done, I skipped on over to Manhattan. First, I headed on over to Central Park, and got a good look at all sorts of interesting wildlife and greenery:

Naturally, as anybody in Manhattan, I spent plenty of time on the subway:

Targeted advertising.

As a Vancouverite, it baffled me just how hot the NYC subway was. The Vancouver SkyTrain is always freezing cold, regardless of the time of year, so I naturally went into the NYC subway with my full jacket on. I was completely wrong.

Anyway, I spent plenty of time walking around Manhattan normally. I first found my way over to Times Square, getting to see big, gold Raisin’ Canes:

then I oogled at all of the advertisements on Times Square:

I also found the crowd at Times Square incredibly interesting:

it was absolutely packed with people! I was so suprised. Next, I did a bit more looking-around, visiting (just outside of) Columbia University and Barnard College, and Tom’s Diner:

Alongside, of course, plenty of Zohran Mamdani posters and Malcolm X landmarks:

When all of this was said and done, I took and AMTRAK over to Boston. I started out by taking a trip over to Northeastern University as a friend of mine goes here:

Then, of course, I headed over to Harvard and MIT as is ritual:

And to end out, I headed over to Salem, MA, to do a witch tour:

And, altogether, it was super fun! There’s a ton more pictures, but in general, I thought this was a fun trip. There wasn’t really much that was all that interesting to see out of the universities, though, because I had already been to Harvard and most of MIT was under construction and blocked off.

Douglas Rushkoff's Cyberia: Objectivity and Reality in the Virtual Age

Sun, 03 Aug 2025 22:55:55 +0000

I recently finished Cyberia by Douglass Rushkoff, and in it, Rushkoff discusses the paradigm shift of the supposed grounded, objective reality essentially losing its footing as humanity begins its exploration into digital consciousness, as virtual space acts as an entirely unique dimension to the one in which we presently inhabit. As such, it operates on entirely different rules. It is as though laws of natural sciences like Physics are of little importance in a digital ecosystem and more abstract, philosopical or sociological ideologies such as metaphysics, abstract mathematics, and religious or spiritual ideas have a heightened applicability. We can most directly feel such a change from its parallel in the shift from an industrial society, marked by technological dominance in the forms of physical engineering, to an information age, marked by technological dominance in the form of largely ideological technology.

From this, Rushkoff’s Cyberia, then, poses some incredible questions, most importantly “Where is this new technology going to take us?” and “How objective is objectivity?” First and foremost, the former question is so pivotal to understanding just how important the virtual age is, and as it is such a complex question to tackle, I won’t go into it. (Rushkoff’s Cyberia spends its length chiefly concerned with finding its answer, so I recommend reading the book to examine that.) Rather, I’m much more interested in the latter question: “How objective is objectivity?,” or, in other words, “How do we define reality?”

So, I start by thinking of our definition of objective reality based on our senses, but similarly, we know that biologically, our senses have to work off of approximations of reality (such as reasonably having a discrete rate at which information is processed, so, for example, time is approximated as continuous in the brain from discrete measurements), so we know that our senses are not as good of a barometer for understanding the underlying nature of reality. Instead, our senses are not much more than exactly what they are: a system for perceiving the working reality necessary to live our lives effectively. What this means isn’t necessarily that what we perceive physically isn’t the “true reality,” but rather, that what we perceive is not guaranteed to be the “true reality,” and this “true reality” may be something beyond our physical or biological perception.

Furthermore, I think that this is just indicative of the failures of perceiving the world as a human being. Another interesting point that Cyberia brings up is on viewing the world under the context of ego (in particular, Cyberia was interested in how the use of psychedelics broke free from this context). Many things that we take as axioms for how the world works, like gender roles, physical perception (like hearing sounds and seeing colors), identity, etc. fall apart when the ego is removed, and the destruction of these axioms ripples out in a fractal-like manner (as the book describes it, where fractals in Chaos theory are uber-sensitive to initial conditions and recursive such that these changes persist and grow over each recursion) to affect all kinds of great conclusions about how we perceive the world.

Kafkaesque and Catch-22's: Bureaucracy, Drugs, Universities, Networking, and Corporations

Sat, 02 Aug 2025 15:45:02 +0000

Hell is on earth, and it’s a waiting room, a line, a series of multicolored files and lengthy emails, weekly zoom meetings, LinkedIn posts, shareholder conferences, university applications, keynote speeches, and god-knows how much other representations of institutional red tape. In such a hell, by the “Nightmare of Interconnection”, all beings within it can be said to be simultaneously its victims and its demons, and the devil at the head of it all isn’t any particular individual, but rather, the system itself.

Of Kafka’s three major works, The Metamorphosis, The Trial, and The Castle, I’ve only read the two former works. In particular, in The Trial, Franz Kafka displays the grotesque, demonic face of the needlessly bureaucratic system in such a way that every member of “civilized” society knows all too well. We’ve constructed a system of of over-organization, one that prioritizes a working order of rules and regulations so much that the the welfare of individuals is considered last, and ironically, such a system becomes so organized that its effectively something of a lawless, unempathetic mess in its final effect.

For example, we write laws with the intent of providing an orderly system of morality and punishment under society, and seemingly, the more rigid laws are written, the more the order is enforced. The more absolute and unchangeable a law is, the easier it is to enforce (and intrinsically, the more fair it becomes). The issue, however, is that just like physical rigidity or hardness of objects, the more rigid a law is, the cleaner it shall break. Loopholes in rigid laws are considerably more exploitable than laws which are flexible and open to interpretation, and although one could argue that flexible laws are easier to produce loopholes for (due to being open to interpretation), again, their flexible nature makes combatting these loopholes similarly simple through exploring other interpretations.

What a rigid society produces is an over-emphasis on rules and order with a lack of interest in the wellbeing of individuals and a fragility in the social order due to being largely unable to change with the course of humanity and thus much quicker to break. What comes immediately to mind is the legislation produced about recreational drugs. Legislation regarding drug use (that being, wide-sweeping bans with immense penalties for illegal distribution or usage) has historically had little to do with the supposed or fronted reasons of promoting social welfare. Rather, it’s far more been a tool for systematically oppressing groups that are the most susceptible to drug use. Controlled substances have been popular in human society from our initial civilizations, especially those like alcohol and medicinal herbs, and despite this, the rhetoric concerning drug use is largely conflicting. The state emphasizes an avoidance of drugs of all kind yet many fail to see the similarities between a drug like alcohol to drugs like Marijuana or psychedelics like psilocybin (magic mushrooms).

Regardless of the negative effects of such drugs, much of which has been studied relentlessly due to this long debate over the decriminalization or legalization of such drugs, we know from history (such as the effects of the prohibition) that wide-sweeping, rigid bans are not in the true interest of social welfare whatsoever. If we truly wanted to aid the population in avoiding addictance to these drugs and lowering deaths due to overdose or poison (from misuse), then the public must be educated about the full range of the effects of drugs alongside the proper, safe consumption of these drugs, and the entirety of the production and distribution system of such drugs must also be made into a legalized process such that the industry can be regulated. It is a fundamental fact of free-market capitalism that where there is a demand, there shall be someone that will look to meet it with a supply. The question thereby lies in the hands of the government: would they rather that someone be somebody above-board that they can control, or somebody unscrupulous whose success entirely depends on evading your control as much as possible?

Furthermore, we engage in the kafkaesque in all manners of society: especially the pipeline of education to the working, corporate world. Due to the capitalism underlying everything in education, much of the education system feels like a peacock show more than its actually about scholarship. For example, scientists are only really scholars as a part-time job. First and foremost, they are salesmen. The success of a researcher, especially in STEM, is largely based on their ability to sell their research to investors (grant funding organizations, such as corporations). Similarly, the success of a student is based on their ability to sell themselves to investors of other kinds, such as the universities, scholarships, or professors they apply to. Universities see the students they admit like investments, with the most likely candidates for admission being those who the university sees as the most likely to be a valuable relationship to have years after graduation. In turn, we see the effect of the children of the uber-wealthy or heads of state being disproportionately admitted to elite universities, but who can blame the colleges? Each admit is something of a gamble to the university, and an already wealthy or well-connected student is a far safer bet for how much the university can profit off of the student later down the line.

Furthermore, the entirety of the topic of networking is such an absurd system from the outside looking in. Many people justify the intense desire to enter elite universities by stating that top universities act as aggregators for the sharpest minds around, and as such, the appeal of a top university is the ability to network with the most powerful leaders-to-be. As James Bryant Conant once stated, “A Harvard education consists of what you learn at Harvard while you are not studying.”

The issue I see with the mentality behind networking is that it views social interaction in such a performative and lain manner. The networking mentality reduces people down into tools for hierarchical advancement, and the irony of advancing in capitalism fundamentally boils down to the idea that you can have anything when you fundamentally don’t need it, and with regards to networking or college applications, any college will quickly accept you and any person will swiftly try to connect with you if they see that their connection with you will allow them to gain something. The irony, therefore, is that the peoplpe that can make the most use out of a university education or a professional connection are those who cannot access it. It’s something of a Catch-22. You need clout or appeal to attract the relationships and positions that will garner you clout. For example, consider job experience. The age-old lamentation is “You need job experience to get a job, but the only way to get job experience is to get a job.” Catch-22, QED.

Our world is red tape and contradictions, rules and operations that make sense at individual levels but come together to produce a whole system that is woefully out-of-order. And what is to remedy it? Burning it down? Is anarchism the answer? Perhaps a return to some idealistic traditional society? In my opinion, probably not, and also due to the nightmare of interconnection. Such problems are probably more intrinsic to humanity than simple the result of the systems we have at hand. However, in all, I don’t know. I just don’t know.

The Nightmare of Interconnection

Thu, 31 Jul 2025 17:12:20 +0000

The nightmare of interconnection is simple: it’s the extension of the perils of individual connections extended to scale of entire networks of conjoined masses. It’s the ripple effect of the transfer of information and ideas from one person to another, the basket of negative effects that continuously seems to arise time and time again both to and from the torment of the masses involved. The nightmare of interconnection, as I choose to refer to it, is something like the underlying beast in systems of people: mob mentality, herd culture, gossip, tyranny of the majority, and so on.

It certainly feels like much of the anti-central establishment ideology and conspiracy theories around shadowy organizations designed to control the masses ever-so-slightly miss the mark of the truth, as the true horror of this nightmare is that individuals are never truly in control or free. Rather, it’s the hidden, invisible beast of interconnection that dominates absolutely everything, and those who hold any power simply find tricky ways to influence the beast’s actions.

I understand that this may come across as an overcomplicated definition or overly-dramatic description of the problems that can arise from people in mass-networks acting as herds, as countless people have studied its patterns and effects throughout history (look no further than the rise of the Nazis, it’s puzzled sociologists for decades just how good-natured Germans could be driven to believe in such racist and vile ideas), but I have chosen to represent it as something like a hidden beast intentionally. It’s the rawest form of humanity: our collective subconscious ideas and desires, and our formation of organized, hierarchical, worker-bee society has sharpened the fangs of the beast as it grew in power alongside the growth of organized civilization itself.

And now, we find ourselves at firmly settled into a new era, one with rapid interconnection of fiber-optic speed. At all times, all peoples connected to the internet are connected to each other, and with this, we connect with far more than merely just our thoughts, jokes, purchases, and the like. We connect our identities, our desires, and our insecurities.

The more we interconnect, the more we lose our sense of self. We become another face in the mob, another like or comment in a sea. And who, just who, is truly in charge? Many point to those who profiteer, the businessmen and polticians that hold the power to influence the actions of the mob, to push advertisements to affect the desires and convictions of the masses to get them to purchase their products or serve in their militaries or otherwise subscribe to their ideals.

However, these people are no more capable of controlling of the collective subconscious than a sailor can control the sea. The nightmare of interconnection, the terrors from the collective subconscious, can be studied, affected, manipulated, and finally exploited in much the way the ocean has for thousands of years, but despite the immense impact humanity has had on the ocean, we still hardly have anything even remotely close to a sense of control over it. The irony of attempts to control the societal subconscious in any form is that any affectation given to it is simultaneously an affectation given to the self. All people within it, meaning all humans, are affected by it through history (as all events, too, are connected). It’s like Milo Minderbinder’s syndicate in Joseph Heller’s Catch-22: “Everybody gets a share.”

To provide some examples, look at autocratic states run by ideologies of distrust or hate. Those spewing the hate, stoking the passionate fire of a desire for purge or blood within the subconscious of the nation’s constituents, can often have that same hate turned right back towards them. Look how quickly Soviet Russia post-revolution could turn against its founders. Lenin was hailed more as an idea than a man, and Trotsky was driven right out of the country only to be later brutally murdered. Look at stories like the assassination of Malcolm X by his own muslims, a betrayal not too unlike the historic assassination of Julius Caesar.

The ideologies or systems these men fight to create become their own worst enemy. Stalin himself was notoriously paranoid of assassination from his closest comrades, fearing that what he had done unto his comrades would be done unto him, leading to the great purge of Soviet Russia where many innocent people were sent to gulags and brutally murdered. Really, it cannot be that Stalin was truly in charge, for he had a master of his own he had to do all in his power to appease throughout his rule. The true kingpin of the USSR was not Joseph Stalin, but rather, it was the all-consuming Bolshevik-turned-Stalinist ideology that was primed to exact its terror on Stalin himself in its quest for constant blood and exact ideological purity, and the only way Stalin could keep its hunger sated to prolong his downfall was to keep maintaining a masquerade of control for as long as he could.

And just think, this behavior of a great fear of the system one has built (a system comprised of fear-based rule) is not the exception for these autocrats (or any leader whatsoever), rather, it’s generally the rule. Presidents fear that their constituents will believe that they have betrayed the ideologies that sworn them in, and all representatives are constantly acting such that they can safely secure re-election.

So, then, I ask again: are these people really in charge? Are individuals, even top executive chairmen of international corporations or political heads-of-state, really to be considered as “running things” as there are? Is anyone, anybody at all, actually at the wheel of this bus? It seems so easy to come up with such daydreams of hidden syndicates of unscrupulous, expensive-suited men deciding the world order between coffee-breaks, but I believe the true entity in charge of the state of the world’s affairs is much, much more of an uncontrollable, unpredictable nightmare.

N00M: My Attempt at Raycasting and 3-D Video Game Design in C

Wed, 30 Jul 2025 08:44:42 +0000

A few months ago, I asked myself what it would take to make a raycaster in C. I’ve seen other programmers before make successful raycasters, namely jdh in one of my favorite videos of his: Programming a first person shooter from scratch like it’s 1995

In particular, I’m incredibly inexperienced in basically all facets of game development, but especially with 3-D games. I’ve only ever made a singular useful graphical program before, mufaro3/sorting-visualization, and it was in C++ using SFML rather than C, and the most I had attempted graphical program design in C was using some basic SDL to draw a few shapes onto the screen about a year or so prior. The bottom line is that in starting this project, I might as well be jumping off into the void.

However, I was really certain that I wanted to understand the basics of 3-D software rendering, as it seemed so incredibly complicated. Therefore, what I set out to do in mufaro3/n00m was to follow Lode’s Computer Graphics Tutorial on raycasting engine development as much as possible to successfully build my own DOOM clone (thus, why I called it N00M, as it’s my own “nickelulzian doomstyle renderer”).

I opted to make N00M in C using SDL for graphics, recp/cglm to simplify the linear algebra calculations, and rxi/log.c for logging. Therefore, to begin with, I set up my C directory as follows (my usual structure):

n00m/
├── src/
│   ├── main.c
│   └── common.h
├── lib/
│   ├── cglm
│   └── log.c
├── res
├── CMakeLists.txt
├── Makefile
├── .gitignore
├── LICENSE
├── AUTHORS
└── README

I first just made sure to set up my build system with a basic headerfile to test if everything could link and build successfully:

#include "common.h"

int 
main(void)
{
  printf( "Hello, World!\n" );
  return 0;  
}

Once this worked, I got started on the actual program structure. Good graphical programs, even in C, are highly modularized, so I started breaking down the system into modules (essentially a variable/struct storing the state of that module for the program at a given time and a header and associated source file for that module with related functions):

graphics for managing everything rendering/graphics related
state for the actual logical game state
config for configuration values managed under config.h and config.c

Then, I started writing out the graphics module directly. I started with some functions to initialize SDL and close the graphics module as

void
graphics_init (graphics_t *gfx, config_t *config)
{
  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
    log_fatal("SDL could not be initialized!\n"
              "SDL Error: %s", SDL_GetError());
    exit(EXIT_FAILURE);
  }

  SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");

  int image_flags = IMG_INIT_PNG | IMG_INIT_JPG | IMG_INIT_TIF;
  int image_init  = IMG_Init(image_flags); 
  
  if ((image_init & image_flags) != image_flags) {
    log_fatal("SDL_image could not be initialized!\n"
              "SDL_image Error: %s", IMG_GetError());
    exit(EXIT_FAILURE);
  }

  if (TTF_Init() == -1) {
    log_error("SDL_TTF could not be initialized!\n"
              "SDL_TTF Error: %s", TTF_GetError());
  }
  
#if defined linux && SDL_VERSION_ATLEAST(2, 0, 8)
  /* Disable compositor bypass */
  if (!SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0")) {
    log_fatal("SDL cannot disable compositor bypass!");
    exit(EXIT_FAILURE);
  }
#endif

  gfx->window = SDL_CreateWindow(config->window_title,
                                 SDL_WINDOWPOS_CENTERED,
                                 SDL_WINDOWPOS_CENTERED,
                                 config->window_width,
                                 config->window_height,
                                 SDL_WINDOW_SHOWN);

  if (!gfx->window) {
    log_fatal("Window could not be created!\n"
              "SDL Error: %s", SDL_GetError());
    SDL_Quit();
    exit(EXIT_FAILURE);
  }

  gfx->renderer = SDL_CreateRenderer(gfx->window, -1,
                                     SDL_RENDERER_PRESENTVSYNC);

  if (!gfx->renderer) {
    log_fatal("Renderer could not be created!\n"
              "SDL Error: %s", SDL_GetError());
    SDL_DestroyWindow(gfx->window);
    SDL_Quit();
    exit(EXIT_FAILURE);
  }

  gfx->screen_texture = SDL_CreateTexture(gfx->renderer,
                                          SDL_PIXELFORMAT_RGBA8888,
                                          SDL_TEXTUREACCESS_STREAMING,
                                          config->window_width,
                                          config->window_height);
}

void
graphics_close (graphics_t *gfx)
{
  SDL_DestroyTexture(gfx->screen_texture);
  SDL_DestroyRenderer(gfx->renderer);
  SDL_DestroyWindow(gfx->window);

  TTF_Quit();
  IMG_Quit();
  SDL_Quit();
}

The idea behind this is that every module will have this same kind of structure, an initialization function and a deinitialization (or close) function. Why this is useful is that it simplifies the general structure of my program. To see this, we can look directly at the main function:

int
main (void)
{
  log_info("Initializing");

  /* setup the random number generator */
  srand(time(0));
  
  config_t config;
  config_load(&config);

  graphics_t gfx;
  graphics_init(&gfx, &config);

  state_t state;
  state_init(&state, &config);

  log_info("Looping");
  
  while (state.running)
    loop(&state, &gfx);
  
  log_info("Closing");
  
  graphics_close(&gfx);
  config_close(&config);
}

The layout of each module’s data structure was pretty simple. In graphics_t, I included some simple SDL pointers necessary for basic rendering. The idea behind graphics_t, after all, is as a singular struct that simplifies passing-in the graphical state of the program into various functions (so any function with a graphical component that may need to access just the SDL_Window context or the SDL_Renderer or etc. can just simply have the entire graphical state passed in at once for simplicity).

typedef struct _graphics {
  SDL_Window *window;
  SDL_Renderer *renderer;
  SDL_Texture *screen_texture;
} graphics_t;

Similarly, the other modules were much the same. The entire game state in state_t was:

typedef struct _fpstimer {
  uint64_t ticks, frames, last_update_time;
  float tps, fps;
  bool infinite_fps;
} fpstimer_t;

/* fonts */
enum { DEJAVU_SANS_MONO, TOTAL_FONTS };

#define TEXTURE_WIDTH  64
#define TEXTURE_HEIGHT 64
#define NUM_TEXTURES   8

typedef struct _state {
  bool running;
  vec2s camera_plane;
  ivec2s map_size;
  ivec2s resolution;

  /* textures */
  uint32_t *textures[NUM_TEXTURES];
  
  /* loaded fonts */
  TTF_Font *fonts[TOTAL_FONTS];
  TTF_Font *debug_font;
  int debug_line_y;

  /* map information */
  map_t map;

  /* controls and whatnot */
  bool keys[SDL_NUM_SCANCODES];
  ivec2s mouse_pos_delta;
  float mouse_sensitivity;
  
  player_t player;
  fpstimer_t timer;
} state_t;

with some code for player information, the presently loaded fonts, debugging info, and some controls and timing variables. Lastly, config_t was much the same:

typedef struct _config {
  uint32_t window_height, window_width;
  uint8_t debug_font_size;
  char window_title[512];

  /* system specification */
  bool is_big_endian;
} config_t;

Altogether, it’s a fairly simple system, and from there, I sought to actually being on rendering. I started by writing in some simple graphics functions (which I won’t show the implementations of, only the declarations):

void graphics_init (graphics_t *gfx, config_t *config);
void graphics_close (graphics_t *gfx);

void graphics_draw_pixel_buffer(graphics_t *gfx, ivec2s resolution, uint32_t *pixels);
void graphics_draw_text (graphics_t *gfx, TTF_Font *font, const char *text,
			 SDL_Color text_color, SDL_Color background_color,
			 int x, int y, int padding);

and a map management system as well:

/* common defines */
#define MAP_OPEN 0
#define NOT_FOUND -1

typedef struct _map {
  int *cells;
  ivec2s size;
} map_t;

SDL_Color map_get_color (int map_value);

void map_init  (map_t *map);
void map_close (map_t *map);

int map_at_vec  (map_t *map, ivec2s pos);
int map_at_fvec (map_t *map, vec2s pos);
int map_at      (map_t *map, int x, int y);

Finally, with this background, I could get started on the following static main file functions:

static void draw_current_frame (graphics_t *gfx, state_t *state);
static void draw_mini_map (graphics_t *gfx, state_t *state);
static void poll_events (state_t *state);
static void handle_keys (state_t *state);
static void draw_debug (graphics_t *gfx, state_t *state, config_t *config);
static void loop (state_t *state, graphics_t *gfx, config_t *config);

The idea behind these is that each handles a specific function. The main loop of the program is performed by loop, events and input are handled by poll_events and handle_keys, and then we have the three main drawing functions: draw_current_frame for the actual game scene, draw_mini_map for the minimap, and draw_debug for the debug screen. In this post, I won’t go into draw_debug, and I’ll mostly focus on the other two.

To begin, drawing the minimap was quite simple. Essentially, what I’m doing is just first performing some calculations to determine how big the minimap should be and where it should be, then I draw the background of the minimap, and then I go in and loop through each of the squares of the minimap to draw in each square unit area by its associated color (as given by its mapvalue).

static void
draw_mini_map (graphics_t *gfx, state_t *state)
{
  /* minimap background constants */
  static const uint8_t BOX_SIZE    = 5; /* width of each box */
  static const uint8_t PADDING     = 1; /* padding for the background */
  static const uint8_t MARGIN      = 2; /* the outer margin */
  static const uint8_t PLAYER_SIZE = 4; /* width/height of the player icon */ 

  /* set up the box sizing for the outer box */
  ivec2s full_minimap_size = ...

  /* determine placement based on the sizing */
  ivec2s full_minimap_position = ...
  /* draw the background */
  SDL_Rect bg_rect = ...
  
  SDL_SetRenderDrawColor(gfx->renderer, EXPAND_COLOR(COLOR_WHITE));
  SDL_RenderFillRect(gfx->renderer, &bg_rect);

  ivec2s box_top_left = glms_ivec2_adds(full_minimap_position, PADDING);

  ...
  
  /* draw all of the boxes */
  for (int x = 0; x < state->map.size.x; ++x) {
    for (int y = 0; y < state->map.size.y; ++y) {      
      /* get the fill color from the position */
      int map_value = map_at(&state->map, x, y);
      SDL_Color fill_color = map_value == MAP_OPEN ? COLOR_BLACK : map_get_color(map_value);

      /* calculate the fill position from the r,c value */
      SDL_Rect box = ...
      
      /* now draw it to the screen */
      SDL_SetRenderDrawColor(gfx->renderer, EXPAND_COLOR(fill_color));
      SDL_RenderFillRect(gfx->renderer, &box);
    }
  }
  
  /* draw a tiny square to represent the player */
  ivec2s player_indicator_center = ...
  
  SDL_Rect player_indicator_bounds = ...

  ...
  
  SDL_SetRenderDrawColor(gfx->renderer, EXPAND_COLOR(COLOR_LIGHT_GRAY));
  SDL_RenderFillRect(gfx->renderer, &player_indicator_bounds);

  /* draw a line to represent the view direction */
  static const int view_line_distance = 20;

  /* normalize the direction vector then scale by the distance */
  vec2s direction_vector;
  glm_vec2_normalize_to((float*) state->player.dir.raw, direction_vector.raw);
  direction_vector = glms_vec2_scale(direction_vector, view_line_distance);

  ivec2s direction_vector_end = glms_ivec2_add(VEC2_INT(direction_vector),
                                               player_indicator_center);
  
  /* draw the vector to the screen */
  SDL_SetRenderDrawColor(gfx->renderer, EXPAND_COLOR(COLOR_LIGHT_GRAY));
  SDL_RenderDrawLine(gfx->renderer, ...
}

From there, I started working on the actual raycasting (the bread and butter of this program).

Note: This post is currently unfinished for some reason. Check back in later to see if I ever ended up coming around to finishing it!

Looking into "Excursions in Number Theory"

Mon, 28 Jul 2025 11:30:18 +0000

In New York, I picked up a new fun textbook, Excursions in Number Theory by C. Stanley Ogilvy and John T. Anderson. It’s a fun little pocketread about all sorts of wacky things in number theory, a field of principle mathematics that seems pointless on the surface but tends to have big implications. The book is fairly short, only 144 pages of direct content, but the information is puzzling to say the least. I found the book next to mathematical books about various games like Poker and Chess, and as this book tackles concepts like probability and combinatorics heavily (as that is where the majority of the implications of number theory seems to lie), it seemed like it fit in well.

In this post, I’m going to dive into the book chapter-by-chapter with some light thoughts, some proofs, and what I think about what was written. Additionally, in order to understand what was going on in each chapter, I sought to try and write some example code alongside each lesson in Common Lisp, so perhaps this could be something of an educational journey for both you, the reader, and me. As usual, it’s best to read this post as though it were a Jupyter notebook (or something of the sort).

Chapter 1: The Beginnings

The book opens by explaining the necessity of number theory. One thing it shows is how number theory serves as the basis by which efficient algorithms for all kinds of calculations is usually produced.

One example the authors provide is the how non-decimal number systems had no mainstream application or use for many years (a topic largely only explored under number theory) until the invention of binary computers, which operate fundamentally on the binary number system (zeroes and ones) and then at higher levels on octal and hexadecimal.

For those unaware, the basic understanding of what a number system is essentially the basis number through which numbers are represented by the multiplication of numbers less than that number by powers of that number. Put more mathematically, we can represent any number that exists using a number system based on the natural number \(n\) by multiplying powers of \(n\) by the whole numbers within \([0,n-1]\). For example, if we wanted to make the number \(N\), we would use the form

\[N = a_1 \times n^0 + a_2 \times n^1 + a_3 \times n^2 + \dots\]

where \(a_i \in [0, n-1]\) for all \(i\). For an even simpler, direct example, the decimal system works where \(n=10\). Imagine we wanted to represent a number like 203463 in decimal (which is just as we normally write it). Therefore, we could represent it as

\[203463 = 2 \times 10^5 + 0 \times 10^4 + 3 \times 10^3 + 4 \times 10^2 + 6 \times 10^1 + 3 \times 10^0.\]

Now, continuing onward, we know that the decimal system makes the most sense for computers because its the easiest to represent (as it only requires two values, 1 and 0. For example, we can represent the number 13 using the following powers, essentially just adding up specific values of powers of 2:

\[13 = 1 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0 = 8 + 4 + 0 + 1,\]

and then, we can represent it as just being the coefficients from that expression, leading us to represent 13 in binary as 1101.

Now, specifically, one of the applications of number theory that the book references is the fast algorithm for converting decimal numbers into binary (as its very quick to convert numbers from non-decimal number systems into demical but seemingly tedious to convert from decimal to non-decimal systems due to having to find and calculate the powers of the system).

This quick algorithm boils down to taking an ordered stock of the pattern in which the division of a number by 2 repeatedly results in odd or even numbers (discarding the \(1/2\) each time the result is odd). For example, for the number 13, we can divide it by 2 until we reach 0, discarding \(\frac{1}{2}\) each time, to get the sequence 13, 6, 3, 1. Then, we can write 1 for each odd number and 0 for each even number and reverse the order, giving 1, 0, 1, 1, which is the digits of 13 in binary (as we showed before).

I thought that this algorithm was ingenious, so I wrote some common lisp code to test it out.

(defun binary (n)
  (labels ((binary-recursive (cur seen)
	     (if (= 0 cur)
		 seen
		 (let ((next-value-int (truncate (/ cur 2))))
		   (binary-recursive next-value-int
				     (cons (if (evenp cur) 0 1) seen))))))
    (binary-recursive n nil)))

and a few tests of the function result in exactly the behavior we expect!

(print (binary 13)) -> (1 1 0 1)
(print (binary 10)) -> (1 0 1 0)
(print (binary 27)) -> (1 1 0 1 1)

Chapter 2: Number Patterns

The next chapter deals with patterns in numbers, such as efficient algorithms for adding numbers. One example they provide is the somewhat legendary story of Gauss adding all of the numbers between 1 and 100 incredibly quickly as a child (I’ll save you all the story: he just knew to pair up numbers on either side of 50 including 0 such that it turned into a product of 11 50s, or \(11 \times 50 = 5050\)).

I thought this chapter was interesting and good foundational mathematics. It deals with series such as the triangular and square numbers and how formulae for adding numbers, squares, and cubes were proven (but not developed) by introducing the method of proof by induction.

Chapter 3: Prime Numbers as Building Blocks

This chapter, obviously, is all about prime numbers: finding primes, calculatings made easy with primes, and relatively prime numbers. One thing it touches on, for example, is Euclid’s algorithm for calculating greatest common denominators as a way to check if two numbers are relatively prime (meaning their only shared factor is 1) or not. The algorithm consists of taking two numbers you want to test, a and b, and then repeatedly changing whichever value is greater to the absolute value of the difference between the two numbers until the two numbers become factorable, at which case the greatest common denominator is the smaller of the two values.

To test this, I wrote the following code

(defun euclid-gcd (a b)
  (if (= 0 (mod a b))
      (min a b)
      (if (> a b)
	  (euclid-gcd (- a b) b)
	  (euclid-gcd a (- b a)))))

Now, Common Lisp does provide Euclid’s greatest common denominator algorithm as a standard library function in the form gcd but I chose to make my own, euclid-gcd regardless. What I found is that this function seemed to work (of course, I can’t test it for all numbers, but we know that by proof given in the book, it works.

Furthermore, this is where things get insane. The book poses the question of “If we picked any two numbers at random, what is the probability that they are relatively prime?,” and it provides a lengthy proof involving the Riemann Zeta function that proves that the probability is \(6/\pi^2,\) or roughly 0.61 (or about 61%). I wanted to test this empirically, so I wrote the following function:

(defun test-probability (to-see max-value)
  (labels ((test-probability-recursive (total-seen prime-pairs)
	     (if (>= total-seen to-see)
		 (/ prime-pairs total-seen)
		 (progn (if (= 1 (euclid-gcd (random max-value)
					     (random max-value)))
			    (incf prime-pairs)
			    nil)
			(test-probability-recursive (1+ total-seen)
						    prime-pairs)))))
    (test-probability-recursive 0 0)))

and with the following test, running the function 10 times, generating 10,000 pairs each time and selecting values within \([0, 10000]\):

(loop for x from 0 to 10 do
      (format T "~f~%" (test-probability 10000 10000)))

I empirically observed the result

So, wow! It was true! I honestly couldn’t believe my eyes when I saw this. That’s just the power of number theory, we could calculate a limit to a problem like that that seemed so random and neigh-unanswerable.

Note: This post is currently unfinished for some reason. Check back in later to see if I ever ended up coming around to finishing it!

The Hypocrisy of Religious Supremacy and Cultural "Civility"

Mon, 28 Jul 2025 06:26:50 +0000

I recently saw an American, Christian white woman exclaim on social media how its not unreasonable to be afraid or suspicious of muslims due to their supposedly violent nature. In particular, she went so far as to claim that islamophobia isn’t real, and is simply a made-up, dismissive term to ignore real concerns and kill any actual discussion about the actions of muslims within western nations like the United States.

Obviously, this woman was largely just fearmongering, but her mentality represents a greater problem within western or historically christian nations: fear hypocrisy. My point is this: we don’t understand things that are not integrated into our society and we fear things we don’t understand, and this sense of fear is self-supporting by events that are caused either in part or in whole by this fear or hate. Things, such as events or people, that support such conclusions are taken in full and things that do not are quickly ignored, all because the image of the status quo in the minds of the masses must be maintained at all costs.

To begin with this discussion, I have to put forward an idea for understanding how people in the world act. We must first begin with the axiom that every person in the world lives with the goal of being happy, and that we each act in whatever way we believe will eventually lead us to achieving what we believe as happiness in our lives. What is important to understand, therefore, is that different people have vastly different ideas of happiness in their minds, and psychologically, it’s most reasonable to believe that the ideal world people envision in which they can be most happy is heavily related to the world in which they grew up. Many people fight outwardly to the world (such as in politics) with the hope of somehow realizing a world they once knew, a world from a time when they felt as though they were happy.

For example, let’s think of social archetypes like NIMBYism. Many people are quick to support the adoption of new ideas so-long as they have no immediate effect on their way of life in any way. Change, inherently, is something terrifying to people, and even long after change has taken effect, people desire to return back to idealized versions of the past that they once knew.

Two things must be taken into consideration from this: understanding what this past often looks like and the problem that naturally arises from that. Firstly, this ideal past is often highly cultural. People can be very adverse to things such as integration because they simply have no desire to enter themselves into the embarrassing comfort of having to come to find a common ground with another group of people. This much is natural, think about the anxiety of meeting new people in the first place. At the very least, on a societal scale, many people who are used to a certain set of demographics (racial, cultural, gender, etc.) within their communities are going to be considerably more open to meeting new people, at the very least, if these people are still at least part of the demographics that they are already well-acquainted-with, and this becomes even worse the more ethnically/culturally homogeneous the community originally was. To put it in plain words, the more white and christian or brown and muslim or etc. a community is, the less the residents would want to integrate any other groups of people. (Again, note that this is not a problem of white people or christians or whatever, this essay is simply dealing with the hypocrisy arising from the integration of muslims into christian, white American/British/Canadian society.)

Secondly, the problem that arises is a cognitive dissonance when coping with change in the forms of integration of new peoples, that being forgetting the nature of one’s own culture in relation to another by way of various excuses to push a final conclusion. For example, some of the major concerns raised about the integration of muslims into American society are the belief that islam is an inherently violent religion, muslims have a history of extreme violence or terrorism within or against the west, and that the values of Islam (such as polygamy) are entirely incompatible with western (again, notably Christian) values. The issue is that each of these concerns lacks an understanding of the present state of Christianity in relation to the present state of Islam, that being, they are very much in parallel.

To begin, we can break down the belief that Islam is an inherently violent religion, especially given the main support to this point, the idea of Jihad (the holy war all muslims are ordered to undertake against all non-believers of Islam). What many christians do not fully comprehend is how the adoption/support of Jihad ideology is a very radical ideology within the muslim community, and most importantly, that Christianity has many of the same things. Nearly every religion has devout, radicalized sects or movements that support ideals of a so-called “Holy War” against non-believers in the modern day.

If we continue further onward to the supposed historical backing of Islam as a violent religion from terrorist attacks or Jihadist wars (such 9/11 and the subsequent war on terror, the London Bombings, the taliban etc.), these events, groups, and wars seem sufficient to paint Islam, at the very least, as a breeding ground for violence until you consider the same historical context for Christians (the crusades, transatlantic slavery and the land grab, the many wars over protestantism, etc.). We can then return back to the original question, whether violence is inherent to Islam, by considering another angle: “How is violence and brutality viewed as a tool for holy dominance in Abrahamic religions?” The answer to this question, I believe, gives us the key to understanding the nature of the cognitive dissonacne I mentioned previously. Obviously, Islam serves as a breeding ground for violence, but so does Christianity, if not historically moreso. Another amazing example is Judaism, as the first testament of the Bible is obviously interpreted by Christians to be overly violent due to the lack of the love and influence of Jesus Christ. Violence, unequivocally, is viewed as a tool for asserting religious dominance over non-believers across religions.

The key to understanding the difference between religions, however, is understanding how each group changes roles over time between being the outward supporter of barbarism and being the supposedly peaceful group. Christianity spent thousands of years as the bloodthirsty hegemon hungry for further control of all society, with the Jews largely split across nations and stateless. Christians position as the hegemon lasted for so long that the requirement for drawing blood in the name of god constantly no longer became necessary, and then it was admissible for these states to claim a push for peace and the use of violence only for protection. In other words, these nations claimed that they were now simply civilized in their matters, and ironically this opinion of themselves as being “civilized” was then used as a justification to promote further violence against cultures they deemed “uncivilized.” It was something of a positive feedback loop: Christians had fought themselves and others so much that extreme, outspoken violence no longer became necessary, so they declared themselves as civilized over nations ruled by Muslims, Hindus, native tribes of foreign lands, etc., but in doing so, they then believed that they ought to continue spreading their culture outward to aid other peoples by civilizing them.

Christians merely swapped roles, they were no longer the barbarians simply winning against other barbarians by brutally murdering them to spread their culture. Now, they were civilized peoples civilizing barbarians by brutally murdering them to spread their culture. And thus, Christian society finds itself at a cognitive dissonance today from the fear of the violence of Islam by not recognizing how violent it has been in spreading its own culture (and how this sentiment is, by no means, gone–it just changes forms).

Lastly, we can examine the claim that the beliefs of Islam and Christianity are incompatible. I’ll concede that, as with any two religions, the devout, fundamentalist sects are likely entirely incompatible (because the more sternly fundamentalist the groups are, even a slight disagreement will make the two groups incompatible), but if we rephrase the question into whether or not eastern, predominantly islamic culture (as we see it in countries such as Egypt or Syria or Iran) is compatible with western, predominantly Christian culture (as we see it in countries such as the US, Canada, or the UK), we generally don’t find it being incompatible whatsoever. Going back to the example of polygamy, polygamy has existed in the US for hundreds of years (however, as a controversial and contested practice), primarily through Christian-adjacent groups such as the Latter-Day Saints (Mormons). More importantly, it’s also key to consider two things: polyamory is presently making a revival in the west due to a greater culture of sexual freedom (which is largely because of the plain fact that it entirely does not and should not matter to the government what consenting adults choose to do sexually or romantically between each other) and islam is not monolitihic on the topic of polygamy: many islamic people are personally monogamous (and, in another consideration, it is important to remember that just like Christians, not all of the religious scripture in the Quran is directly and literally followed).

Now, to end out this post, I’d like to notice that some people reading this may be especially curious as to why I singled out white christians over other races in a post primarily dealing with religion. This is because this post deals with the issue of religious prejudice but all of the topics within it are heavily related to racial prejudice. Christianity was historically used as a justification of racial injustices of all kind: from justifying the scramble for Africa/America and the transatlantic slave trade to upholding systems such as segregation long after the international abolition of slavery. Therefore, to summarize my beliefs, I see anti-integrationist, islamophobic western attitudes as ironic and hypocritical.

How I Created and Manage This Website

Sun, 27 Jul 2025 09:24:41 +0000

I’ve previously received a questions asking for advice on how to create a website like mine, and in order to help others looking to make blog sites or portfolios like this, I thought I’d give a full technical breakdown of how this website works, including web design, hosting, domain management, and lastly, article writing. Beware: to make a website like this, you will need to be comfortable with both the heavy technical aspects of running a site like this alongside the creative aspects of producing this content. The biggest pro to this website is that the vast majority of this website (and all of its core functions) are completely free to produce, run, and manage, but there are several bells and whistles that I willingly fork up about 30 USD yearly to operate, and I’ll explain why shortly.

Hosting

This website is hosted through GitHub Pages, which is an entirely-free static website hosting service that operatures through hosting out of GitHub repositories. All you need to do to make a basic github pages site is to first make a GitHub account and then follow the instructions on the GitHub Pages landing page to produce the minimal github pages example, which will be hosted at (your github username).github.io. This domain is provided free-of-charge by GitHub, but I didn’t quite like it (mufaro3.github.io), so I switched to a custom domain (see “Domain Management”).

It’s a simple process to get set-up, and all you really need to understand for this section is how to make a github repository named correctly (to auto-integrate github pages), and then from there, the rest is web design.

Web Design (Programming)

Now, remember how I said that this site is a static site. That means that it’s contents are (mostly) non-dymanic, meaning that there is no database attached to this website in any way. Dynamic elements of the site are website contents that aren’t directly attributed to the site contents and can change regularly without manually changing the site, and this site does contain some dynamic elements such as the youtube videos, user comments, and a (soon-to-be) mailing-list, but these elements are all embedded from other services.

In the case of this site, all of the page contents are generated from special text files known as Markdown using Jekyll, a popular static site generator written in the programming language Ruby. The main advantage of this is that all of the posts on the site are very easily and concisely written in Markdown then compiled out into the HTML that you view on your web browser. Most importantly, due to Jekyll’s popularity, it has a quick-and-easy integration for GitHub pages, not requiring any compilation to occur locally (although, I obviously could just compile the site locally and have GitHub pages serve the compiled form).

Theming

For theming on Jekyll, I started by taking a theme that already exists, Gildasio’s Clyell, and started adapting it manually. There are many Jekyll tutorials available online, so I’m not going to get into the specifics for how each element of this website was adapted from Clyell (there is a lot), but to give a general summary, I cleaned up and standardized the theming system of main.css, moved all of the syntax highlighting parts of main.css out and introduced a different theme (gruvbox), and removed bootstrap (the css library). If you don’t understand basic HTML/CSS, most of what I just said won’t make sense, but similarly, any further tweaking to the layout of the webpage won’t really make sense if you don’t understand HTML and CSS, so if you wish to make a blog website like this without learning those things, just download a premade theme from a website like Jekyll Themes and don’t make any changes.

Domain Management

GitHub Pages automatically provides a domain for all websites it hosts, the aforementioned <username>.github.io, but I didn’t really like this domain (plus, I wanted a cool custom e-mail address), so I purchased a custom domain from NameCheap for about 15 USD a year alongside another 15 USD a year for one custom email address for a total of 30 USD a year for everything. From there, all I needed to do was configure the GitHub Pages site to automatically force any users that connect to the website to connect via my domain by setting the domain of the website on the repository settings, and while there, I also set the website to automatically enforce HTTPS over HTTP (so all traffic to/from this website is automatically encrypted).

Article Writing

The Technical Part

Posts have to be stored under _posts in a very specific way, that being

YYYY-MM-DD-<post-link>.md

and each post requires a header like

---
layout: post
title:  "a look into a quantum mechanical carnot engine (alongside a bit of python)"
date:   2025-07-24 12:19:00
comments: true
categories:
    - programming
tags:
    - physics
    - python
    - mathematics
---

So, to automate this, I have a bash script under _posts labelled newpost.sh. Let’s say, for example, that I wanted to write a new post on the basics of number theory. I would first cd into the _posts directory then call newpost.sh:

$ cd ./_posts/
$ ./newpost.sh number-theory-basics

Let’s say that the current time as of running that command was January 10th, 2026, at 12:37 PM (48 seconds in, or 12:37:48). The script would therefore know to generate the file _posts/2026-01-10-number-theory-basics.md storing

layout: post
title:  "number-theory-basics"
date:   2026-01-10 12:37:48
comments: true
categories:
    - category
tags:
    - tag
---

and from there, I would open the file with emacs with

$ emacs -nw ./2026-01-10-number-theory-basics.md

and just edit in the title and tags and the category to produce something like

layout: post
title:  "An Explanation of the Basics of Number Theory"
date:   2026-01-10 12:37:48
comments: true
categories:
    - programming
tags:
    - mathematics
---

Keep in mind that “programming” doesn’t mean that it’s an article about programming, it just means that it will end up on the “programming”/STEM board that I call lambda.

From there, I just write the post content normally in Markdown on Emacs. Once I’m done writing, I add the new file to the git working tree with git add

$ git add ./2026-01-10-number-theory-basics.md

and then commit that file alongside any other changes I made with a short comment about what changed

$ git commit . -m 'basics of number theory article'

and lastly, I push the article to the main branch.

$ git push

This is a considerably easier process with editors like Visual Studio Code that have simpler, non-terminal Git integration, but I don’t have a problem with doing it all manually via terminal and editing with Emacs. I like it this way.

The Artistic/Motivational Part

Lastly, for the motivational part, I keep a small notepad with me where I write down ideas whenever I get them (such as short questions that bug me) and then I settle them by sitting down and writing an article. Like they say, a man that’s thinking all the time will have nothing to think about but thoughts, so the best way to think about things worth writing about is to not think about things worth writing about, but instead, go out and live your life for a while and then things will come to you, and when they do, save those ideas somewhere.

Most of the things that I have written about thus far are projects that I worked on for fun months prior without ever intending to really do a full write-up, but afterward, I thought it would be useful to write a description of what happened, what worked, what didn’t, and what I learned. For any creators or experimenters out there, I think that format is really worth a try.

It’s incredibly easy to avoid writer’s block when you aren’t trying to force ideas out of you. Some ideas just come naturally, and when they do, you need to listen. Those are the ideas most worth writing down. It always seems like they come at the dumbest times, like when you’re taking a bath or going for a walk or brushing your teeth or some shit, but ironically, those mundane moments where you’re just existing in monotony are the best for thinking because your brain understands just how meaningless that time is. I think that meaningless time really has all the time in the world for that exact reason. Spend more of your life actually living it than thinking or writing and then think and write as much as you can.