https://amrita.town/blogroll recent posts from the amrita.town webring en Fri, 26 Jun 2026 17:41:34 GMT https://nithitsuki.com/posts/theres-levels-to-art/ https://nithitsuki.com/posts/theres-levels-to-art/ Sat, 20 Jun 2026 11:30:12 GMT Nithilan Rameshkumar and I'm definitely on the lower ranks https://bananameatpatty.vercel.app/blog/chandra-toueg/ https://bananameatpatty.vercel.app/blog/chandra-toueg/ Wed, 17 Jun 2026 00:00:00 GMT Praneeth V Imagine five friends trying to pick one restaurant over a group chat. People drop offline mid-conversation. Messages arrive late. Nobody can tell whether Nandana left or is just slow to type. And yet — somehow — the group has to end up at exactly one restaurant, with nobody walking into a different door. That, stripped of the food, is the consensus problem. The Chandra–Toueg algorithm (1996) is a famous, elegant way to actually solve it when computers can crash. It shares its core ideas — a leader, majority quorums, “freshest value wins” — with Paxos and Raft, the protocols running inside basically every serious distributed database today. (Paxos was developed independently around the same time, not derived from it — they’re siblings, not parent and child.) https://nithitsuki.com/posts/lastfm/ https://nithitsuki.com/posts/lastfm/ Sun, 07 Jun 2026 19:01:12 GMT Nithilan Rameshkumar on why you should use last.fm, a website for music lovers https://namishh.com/journal/2026-05-26 https://namishh.com/journal/2026-05-26 Tue, 26 May 2026 00:00:00 GMT Namish Pande convering my thoughts on first year of college. https://nithitsuki.com/posts/name-your-contacts-like-a-psychopath/ https://nithitsuki.com/posts/name-your-contacts-like-a-psychopath/ Sun, 24 May 2026 19:10:12 GMT Nithilan Rameshkumar and how it has saved me on countless random occasions https://adithyanair.com/blog/niche/ https://adithyanair.com/blog/niche/ Sat, 16 May 2026 00:00:00 GMT Adithya Nair A random rabbit hole I want to document. https://hrideshmg.com/p/stm32-hack/ https://hrideshmg.com/p/stm32-hack/ Mon, 11 May 2026 00:00:00 GMT Hridesh MG For our embedded systems course this semester we were given two choices — either use a simulator or actually build a project using hardware. Now, let me set the scene: All of this was scheduled right before our finals. Any sane individual would have chosen the simulator, however as you could probably guess by the length of this blog, I am not a very sane individual :) The Hardware Given the time constraints, I picked the simplest thing I could think of: read temperature and humidity from a DHT11 sensor and display it on a tiny OLED. If you have any experience with electronics, this is a pretty beginner friendly project, or so I thought.. You see, my prior experience with embedded electronics were confined to the comforts of the Arduino ecosystem with its easy to understand IDE. However, for this project, we were required to use an ARM STM32 microcontroller, that too without any of the higher level abstractions (HAL). This meant that I had to do raw register manipulation and directly write C code for everything. Now, granted, we did learn most of this stuff during our course. However, we used the STM32F446RE Nucelo Board, a board which costs around 2k INR. Me being the cheapskate that I am, decided to opt for an STM32F103C8T6 board instead. This board only costed only around 200 INR, 10x decrease! I casually read through the specs and naively assumed that since this board used the same ARM Cortex architecture that the Nucleo board uses, it wouldn’t pose any problems. Boy, was I wrong. The Beginning Of My Woes I ordered the board from Amazon, and it arrived with the header pins separately. I expected this, so I took out my borrowed soldering iron and began soldering the pins onto the board. After this, I hooked up the ST-Link programmer to the board. Installed the ARM Keil IDE and started writing code for a simple LED blink script (the hello world of electronics!). That’s when my electronics illiterate brain realized, since this is a different chip, the pinouts and registers are different than what I’m used to. Cue me slogging through the schematic and a 1,000 page reference manual to figure out which pin the onboard LED is connected to and which bits to set in the register. After I was done writing the code, I successfully built it and tried to upload it to my board. That’s when I got this magnificent error: The Chinese Counterfeit Strikes Again Suffice to say, I was pretty cooked at this point, the official IDE was claiming that I was using a cloned chip and refused to flash it. I poked around a bit and managed to find the IDCODE of the chip, it was 0x2BA01477 which was not the ID of an original STM32F103C8T6. I did some research and managed to find this article. They had mentioned the exact same chip ID, confirming that this was indeed a chinese clone. The real name of this cuckoo was in fact CS32F103. The only thing betraying it was the IDCODE as the markings on the IC itself were identical to the original chip. One thing I found particularly amusing was that the company which cloned this chip did such a good job that they even fixed some of the errata listed in the original ST datasheet. Imagine that, a counterfeit was in some small way better than the original. Merely knowing that the chip was a clone wasn’t of much help though. I couldn’t find any good resources on Google with instructions on how to get around the IDE lockout. The Workaround With the help of Claude, I managed to unearth two ancient articles. The first one was the documentation of some Chinese embedded tools company? And the second was a blogger article from 8 years ago that explained how to download an older version of the IDE (this will become relevant soon). The Chinese site somehow had an unofficial IDE pack for the CS32F103, I could not find this on the internet anywhere else and frankly I have no idea how they even got their hands on it. Unfortunately, the patch was incompatible with the latest version of the IDE. The solution is simple enough, just download an older version. However, Keil in all their glory have gone out of their way to make this as difficult as possible. Remember that 8-year-old blogger article from earlier? That was the only working method I could find, the author had conveniently left an expired product key for the IDE and possesing such a key was the only way to access old versions. The (blinking) light at the end of the tunnel Finally, after installing an archaic version of the IDE and installing a shady patch from a Chinese website, I was able to flash my board. All of this work, just to get an LED to blink. Words couldn’t describe how satisfied I felt at that moment, this satisfaction was however pretty short lived, because that’s when I remembered—I hadn’t even started work on the actual project…. https://decentparadox.me/blog/neumann-devlog/ https://decentparadox.me/blog/neumann-devlog/ Mon, 04 May 2026 00:00:00 GMT Sasank Reddy Month-by-month log of building a localhost AI code editor in Rust — the decisions, the rewrites, the postmortems, and what actually shipped. https://compileartisan.dev/blog/second-nature/ https://compileartisan.dev/blog/second-nature/ Mon, 13 Apr 2026 00:00:00 GMT Praanesh Nair How I define second-nature https://nithitsuki.com/posts/get-atom-rss-on-hugo/ https://nithitsuki.com/posts/get-atom-rss-on-hugo/ Mon, 16 Feb 2026 17:49:12 GMT Nithilan Rameshkumar add Atom feed support to hugo https://nithitsuki.com/posts/anokha/ https://nithitsuki.com/posts/anokha/ Sun, 08 Feb 2026 00:00:00 GMT Nithilan Rameshkumar diray entry wannabe travel blog about Anokha 2026 https://heftymouse.me/blog/astro-rss-images/ https://heftymouse.me/blog/astro-rss-images/ Sun, 08 Feb 2026 00:00:00 GMT Nikhil Bharadwaj And taking the picturesque route to solve this https://adithyanair.com/blog/reviews/ https://adithyanair.com/blog/reviews/ Sun, 08 Feb 2026 00:00:00 GMT Adithya Nair A small piece on what I like to think about while reviewing. https://hrideshmg.com/p/smart-beta/ https://hrideshmg.com/p/smart-beta/ Thu, 08 Jan 2026 00:00:00 GMT Hridesh MG Disclaimer: Do not take anything written in this blog as investment advice, please do your own research before making any financial decisions. A few months ago, when I started getting into finance, Zerodha Varsity was my go-to resource. I owe much of my finance/stock-market knowledge to the excellent modules over there. While I reading through the mutual fund module, one article in particular stood out to me - “Smart-Beta Funds”. What surprised me wasn’t the concept itself, but how little discussion it had compared to other varsity articles. While most modules had hundreds if not thousands of comments, this one had a meagre 25-30. This lack of attention felt odd, and as someone who likes to dig into things that fly under the radar I decided to look deeper into them. This blog is an attempt to summarize my learnings and present some of the analysis I’ve done on these funds. I’ll try my best to keep it as beginner friendly as possible so don’t worry if you don’t know anything about these funds. Index Funds One of the best ways to understand something is to draw parallels to an already known concept, which is why I’ll compare Smart-Beta funds to Index Funds. An index fund is simply a fund which tracks a certain index like the Nifty 50 or the Sensex, what this means is that if your entire portfolio was composed of a single index fund, it would move almost exactly like the index that it is tracking. Index Funds vs Mutual Funds Here is something that may surprise a lot of you: Index funds outperform the majority of actively managed funds over the long term. This is almost a universal consensus among most finance-savvy investors. One of the primary causes for this being lower expense ratios that compound over time. Don’t just take my word for it though, investing legend Warren Buffet once remarked — “If a statue is ever erected to honor the person who has done the most for American investors, the handsdown choice should be Jack Bogle.” Jack Bogle being, of course, the inventor of the world’s first index fund (the Vanguard 500 Index Fund). If you’re someone who is more data inclined, feel free to take a look at the SPIVA India reports published by S&P global, which compares the performance of active and passive (index) funds. The 3 and 5-year horizons are of particular interest as 80-90% of active funds see underperformance compared to passive ones. Index funds represent the purest form of passive investing, but they don’t represent the totality of the spectrum. What if there was a way to tweak certain characteristics of the index? That is where the magic of Smart-Beta funds come into play. What is a “Smart”-beta fund? Contrary to its name, “Smart” beta funds aren’t actually all that smart, it’s more of a marketing term if anything. This style of investing is more commonly referred to as factor investing. Factor based funds sit between active and passive funds. They still have low expense ratios and a pre-defined formula, but unlike index funds, they do not weight stocks by market cap alone. The funds are weighted by certain characteristics called “factors”, few examples of factors are: Momentum (recent winners) Value (cheap stocks) Quality (strong balance sheets) Low Volatility (consistent share price) To take momentum as an example, a momentum-factor based fund (like the Nifty Midcap150 Momentum 50) would pick stocks which show the largest recent returns in a specific time period. These funds are usually rebalanced every 6 months or so. Smart-Beta funds are passive at their core, but they put a spin on the traditional index fund by using specific formulas to decide which stocks become part of the fund. Do Smart-Beta funds Work? This is probably the question that all of you are most interested in. While I was doing my research into these funds, I came across this research article from S&P global which conducted a data analysis on single-factor funds in the US market. What they found was that single-factor indices often outperform traditional index funds over the long term. However, they are subject to distinct cycles of underperformance. The article recommends blending different seemingly inversely related factors together to create a more stable source of returns. However, keep in mind that all of this analysis was done on U.S. markets. I could find no such detailed research conducted on the Indian markets (please do comment down below if you find any) So, naturally, I did what any bored computer science student with too much time on their hands would do — I wrote some code to analyze the historical performance myself :) Digging Into The Data Now, fair warning! I’m not a data scientist or a research analyst. So there may be some errors that have crept in due to my inexperience. If you wish to proofread it, the colab notebook and raw price data used for generating the below insights is open-source and available here. One important thing to remember is that past performance are not indicative of future returns. That said, I still do think that historical data is a useful tool, this article wouldn’t exist otherwise ;) Source The stock market data for the different indices was obtained from NSE’s website. I’ve used the past 10 years stock data from 01-01-2015 to 25-04-2025. The choice of 10 years was, to be honest, completely arbitrary, it just felt like a good enough sample space when I did this analysis. I had randomly chosen the following few indices for comparison: Nifty 50 (Benchmark) Gold (Benchmark) Nifty Midcap 150 (Benchmark) Nifty Alpha 50 Nifty 50 Low Volatility Nifty Midcap 150 Quality Nifty Midcap 150 Momentum Nifty 200 Momentum Nifty 200 Quality Nifty 200 Value Nifty 200 Alpha Nifty Smallcap 250 Quality If you’re annoyed by the lack of diversity in same-sized factor indices (like the absence of a Nifty 150 Value), you’re not alone. NSE doesn’t recognize these as official indices, so they simply don’t exist. As for why they don’t exist, your guess is as good as mine. Methodology I’ve chosen to compare the indices based on the following few metrics: CAGR: Average yearly growth rate of the index. Rolling Returns: Overlapping returns calculated over 1-year, 3-year and 5-year periods. Sharpe Ratio: Volatility adjusted returns. Max Drawdown: Largest percentage drop from a peak to a trough in 10 years. Annual Volatility: How much the index tends to fluctuate in a year. In addition to the above, I’ve also measured how “in-sync” these indices move with respect to each other through a correlation matrix. I got inspiration to do this from the S&P report, which found that in U.S. markets certain indices are inversely correlated, meaning that combining them could yield better stability. Of all these metrics, the two most important ones are the Sharpe ratio and rolling returns. Sharpe? What’s that? If you’re a seasoned investor, you’ve probably seen most of the metrics that I have listed above — except maybe the Sharpe ratio. Though its more commonly used by quant traders, I believe that its an effective way to compare returns while accounting for risk. The Sharpe ratio, simply put tells you how much extra return an investment delivers for the risk you take to get it. A higher ratio is better (more return for each unit of risk). If you’re interested in more details, I’d recommend checking out this excellent video: Results Key Metrics The table below compares the key metrics I mentioned earlier across the benchmark and smart-beta indices over the past 10 years. It is sorted according the Sharpe ratio. Index CAGR (%) Max Drawdown (%) Annual Volatility (%) Sharpe Ratio Nifty Midcap 150 Momentum0.20-39.610.191.02 Nifty Midcap 1500.11-38.670.190.97 Nifty 50 Low Volatility0.12-29.330.140.91 Nifty 200 Alpha0.18-37.500.210.84 Nifty Smallcap 250 Quality0.15-51.910.190.81 Nifty 200 Momentum0.16-34.210.200.80 Nifty Midcap 150 Quality0.12-36.260.160.79 Nifty Alpha 500.17-40.670.220.78 Nifty 200 Quality0.10-29.510.150.70 Gold0.09-22.000.140.67 Nifty 500.10-38.440.170.63 Nifty 200 Value0.10-60.740.230.46 Rolling Returns Relying too heavily on 10-year metrics can be misleading. In practice, investors rarely think in such long, fixed timeframes. What matters far more are the returns one can reasonably expect over shorter horizons, such as 1-year, 3-year, or 5-year periods. This is precisely what rolling returns helps us to calculate: 1-Year Index Median (%) Max (%) Min (%) Nifty Midcap 15024.80111.92-34.44 Nifty Midcap 150 Momentum20.33117.42-25.76 Nifty Alpha 5017.82155.47-29.71 Nifty Smallcap 250 Quality17.38126.86-40.91 Nifty 200 Alpha16.8994.24-28.06 Nifty 200 Momentum16.2683.07-26.50 Nifty 200 Value15.33122.79-49.22 Nifty Midcap 150 Quality14.4995.27-29.52 Nifty 50 Low Volatility11.8673.76-22.34 Nifty 5011.7994.67-33.40 Nifty 200 Quality10.1972.80-26.04 Gold6.9146.57-16.30 3-Year Index Median (%) Max (%) Min (%) Nifty Midcap 15026.1539.8913.87 Nifty Midcap 150 Momentum22.2344.36-3.11 Nifty Alpha 5020.8146.82-4.85 Nifty 200 Alpha19.5834.96-2.37 Nifty 200 Momentum19.0231.100.11 Nifty Smallcap 250 Quality18.4746.97-14.18 Nifty Midcap 150 Quality15.1728.59-3.40 Nifty 50 Low Volatility13.5125.71-2.51 Nifty 5013.1631.64-5.25 Nifty 200 Quality12.4725.03-1.40 Nifty 200 Value9.9047.50-22.32 Gold7.2220.28-2.53 5-Year Index Median (%) Max (%) Min (%) Nifty Midcap 15026.8536.9021.45 Nifty Alpha 5022.7439.540.54 Nifty Midcap 150 Momentum21.4839.993.87 Nifty 200 Alpha18.8333.764.83 Nifty 200 Momentum18.2129.995.38 Nifty Smallcap 250 Quality15.7437.87-3.01 Nifty Midcap 150 Quality14.7524.111.78 Nifty 5013.2524.57-2.79 Nifty 50 Low Volatility13.1224.091.43 Nifty 200 Quality13.1121.08-0.48 Gold8.4914.923.19 Nifty 200 Value6.9843.25-12.51 Correlation Matrix .table-scroll { overflow-x: auto; -webkit-overflow-scrolling: touch; margin: 1em 0; } .correlation-matrix { font-size: 0.85em; background-color: #1a1a1a; color: #e0e0e0; min-width: 600px; } .correlation-matrix th { background-color: #2a2a2a; font-weight: 600; text-align: center; padding: 8px 4px; font-size: 0.75em; border: 1px solid #3a3a3a; white-space: nowrap; } .correlation-matrix td { text-align: center; padding: 6px 4px; border: 1px solid #3a3a3a; white-space: nowrap; } .correlation-matrix tbody tr td:first-child { font-weight: 600; text-align: left; background-color: #2a2a2a; position: sticky; left: 0; z-index: 1; } .corr-high { background-color: #1a3a2a; color: #90ee90; } .corr-med { background-color: #3a3a1a; color: #ffd700; } .corr-low { background-color: #3a1a1a; color: #ff6b6b; } .corr-diag { background-color: #2a2a2a; font-weight: 600; color: #b0b0b0; } Nifty 50 Alpha 50 Low Vol MC150 Qual MC150 Mom 200 Mom 200 Qual 200 Val 200 Alpha SC250 Qual MC 150 Gold Nifty 501.000.780.900.820.800.860.860.790.830.750.840.04 Nifty Alpha 500.781.000.810.880.940.900.780.810.930.880.930.06 Nifty 50 Low Vol0.900.811.000.880.840.870.940.780.850.790.880.05 Nifty MC150 Quality0.820.880.881.000.920.860.860.790.880.890.950.05 Nifty MC150 Momentum0.800.940.840.921.000.920.810.810.930.870.960.07 Nifty 200 Momentum0.860.900.870.860.921.000.840.820.970.810.890.06 Nifty 200 Quality0.860.780.940.860.810.841.000.720.840.750.830.06 Nifty 200 Value0.790.810.780.790.810.820.721.000.830.780.860.08 Nifty 200 Alpha0.830.930.850.880.930.970.840.831.000.830.910.06 Nifty SC250 Quality0.750.880.790.890.870.810.750.780.831.000.910.04 Nifty Midcap 1500.840.930.880.950.960.890.830.860.910.911.000.07 Gold0.040.060.050.050.070.060.060.080.060.040.071.00 Conclusion While I started this analysis to understand the performance of smart-beta funds, I was more surprised by how much better the Nifty Midcap 150 performs compared to the Nifty 50 for only a modest increase in volatility. Another interesting observation was how highly correlated all of these indices are, a lot of them move almost in-sync. This is in direct contrast to the U.S. market in which some factors even exhibit negative correlations. The only instrument that had a low correlation was gold, interestingly though, even it did not have a negative correlation. Which may cast some doubt on the claim that gold can be reliably used as a hedge for portfolios. I’ve purposefully avoided drawing any conclusions about individual indices, because ultimately, I think that’s a call you should make yourself :) Hope you found this useful, or at the very least sparked some new ideas! https://heftymouse.me/blog/lonely-planet-india/ https://heftymouse.me/blog/lonely-planet-india/ Sat, 20 Dec 2025 00:00:00 GMT Nikhil Bharadwaj This city is not what it used to be https://adithyanair.com/blog/the-truman-show/ https://adithyanair.com/blog/the-truman-show/ Sat, 20 Dec 2025 00:00:00 GMT Adithya Nair A small analysis of Christof, the showrunner. https://compileartisan.dev/blog/my-love-for-cars/ https://compileartisan.dev/blog/my-love-for-cars/ Thu, 04 Dec 2025 00:00:00 GMT Praanesh Nair I explain what I truly feel when I drive a car https://adithyanair.com/blog/epoch/ https://adithyanair.com/blog/epoch/ Mon, 01 Dec 2025 00:00:00 GMT Adithya Nair A small note on what we did and the inspiration behind it. https://nithitsuki.com/posts/boot-from-nvme-drive-on-an-unsupported-motherboard-uefi-only/ https://nithitsuki.com/posts/boot-from-nvme-drive-on-an-unsupported-motherboard-uefi-only/ Fri, 28 Nov 2025 11:30:11 GMT Nithilan Rameshkumar for mobo's that do not support booting from PCIe slots https://adithyanair.com/blog/raindrop/ https://adithyanair.com/blog/raindrop/ Mon, 10 Nov 2025 00:00:00 GMT Adithya Nair A small note on how I'm organizing my bookmarks moving forward. https://namishh.com/blog/devlogs/pico https://namishh.com/blog/devlogs/pico Sun, 02 Nov 2025 00:00:00 GMT Namish Pande Read more about this content https://ngpal.github.io/brainspace/Projects/Mango---Toy-language-compiler/0.-A-Long-Introduction https://ngpal.github.io/brainspace/Projects/Mango---Toy-language-compiler/0.-A-Long-Introduction Fri, 05 Sep 2025 00:00:00 GMT Nandagopal Menon Making your own programming language is actually far easier that you think it is, mostly because there’s a good chance you have some definitions mixed up ... https://ngpal.github.io/brainspace/Projects/Mango---Toy-language-compiler/ https://ngpal.github.io/brainspace/Projects/Mango---Toy-language-compiler/ Thu, 04 Sep 2025 00:00:00 GMT Nandagopal Menon The Idea I have wanted to make a compiler for the longest time. Just the idea of making my own programming language, that can translate down into machine code and run straight on the machine is just so exciting to me. https://namishh.com/poems/train https://namishh.com/poems/train Mon, 01 Sep 2025 00:00:00 GMT Namish Pande will write a description later https://compileartisan.dev/blog/my-favourite-things-on-the-internet/ https://compileartisan.dev/blog/my-favourite-things-on-the-internet/ Fri, 08 Aug 2025 00:00:00 GMT Praanesh Nair A comprehensive list of the most unique things which have fascinated me on the Internet https://hrideshmg.com/p/reversing-turbo/ https://hrideshmg.com/p/reversing-turbo/ Sun, 20 Jul 2025 00:00:00 GMT Hridesh MG As promised on my blog post about the Linux Kernel mentorship program, this article will be about my endeavours in trying to enable turbo support for my laptop on Linux. How it all began It all started one day when I was sitting in front of my laptop completely zoned out. My eyes glanced upon the keyboard and I caught myself staring at a key which usually opens an app to change performance profiles of the laptop. Now, much to the surprise of nobody, this key did not do anything on Linux since the NitroSense app (as is the case with most proprietary software) only works on Windows, regardless, I still wondered if it was possible to change thermal profiles on Linux. To my surprise, someone had already made a kernel module for this purpose! Unfortunately (or fortunately, since we wouldn’t have this article otherwise :)) it only supported the Acer Predator Series of laptops, whereas my laptop was from the Nitro Series. Anyways, it proved as a good starting point and while going through the source code of the project, I realized that this module was nothing more than a modified fork of a module from the platform profile subsystem on the kernel tree. Let the tinkering begin! Finding The Hidden Interface After a brief skim through the project, I understood that things like RGB LEDs, fan profiles and certain other hardware related functionalities are often controlled through something known as WMI, during this phase I also chanced upon a youtube miniseries created by the author of the project which gave me some great insight into how this project works under the hood. In short, the WMI interface allows software to communicate with the hardware by sending certain commands. These commands are handled by special WMI entries defined in the ACPI tables stored in the system firmware. That’s a whole lot of words just to say — system send command, hardware do thing. Playing around with WMI First off I started by randomly tweaking a few values in the source code (sidenote: you probably shouldn’t be doing this at the kernel level!) and briefly got my fans to spin to their maximum speeds but the thermal profiles did not seem to budge, my CPU was still throttled at a respectable 3.2 GHz and I was none the wiserRegardless, this confirmed my assumptions regarding WMI and thus I booted into Windows to monitor WMI activity and sure enough, whenever I changed thermal profiles using the app, a WMI event was registered on the Windows Event Viewer. The monitor told me that two WMI functions - SetGamingFanBehavior and SetGamingMiscSetting were called for changing fan speeds and applying overclocks respectively. Just knowing this alone wasn’t enough though, I also needed to know what inputs are fed into these methods so that they actually do something. The event viewer, sadly, provided no means to track inputs. WMI Explorer Initially, I tried to do some trial and error using a tool I discovered called WMI Explorer to manually invoke these functions but it didn’t seem to do anything. I later realized that the only way to figure out the required inputs was to reverse engineer the program which calls the function. I also made a small documentation patch during this time to mention this neat little tool in the WMI driver development guide. Reversing the NitroSense app Thus it began, my first foray into reverse engineering a real app. The NitroSense app was written in C# and thus I used dotPeek to decompile it. Fan Modes Cracked While searching for the input values for the overclock WMI call, I coincidentally chanced upon the function that was responsible for setting the fan modes — 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public static bool set_all_fan_mode(CommonFunction.Fan_Mode_Type mode_index) { ulong intput = 9; switch (mode_index) { case CommonFunction.Fan_Mode_Type.Auto: intput |= 4259840UL; break; case CommonFunction.Fan_Mode_Type.Max: intput |= 8519680UL; break; case CommonFunction.Fan_Mode_Type.Custom: intput |= 12779520UL; break; } return ((int) WMIFunction.SetAcerGamingFanGroupBehavior(intput).GetAwaiter().GetResult() & (int) byte.MaxValue) == 0; } As we can see, input values of the WMI function are readily available here! There are three magic values which correspond to the three different fan modes. Was a bit surprised to the see the typo in the ‘intput’ variable, kind of refreshing to know that even billion dollar companies have such mistakes in their code lol. In Search Of Overclocks.. The overclock function was sadly not as simple of an egg to crack. I traced through the GUI code for the app and narrowed it down to this particular function - 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public static async Task<int> set_operation_mode(int Operation_Mode) { int output = -1; try { NamedPipeClientStream cline_stream = new NamedPipeClientStream(".", "PredatorSense_service_namedpipe", PipeDirection.InOut); cline_stream.Connect(); output = await Task.Run<int>((Func<int>) (() => { IPCMethods.SendCommandByNamedPipe(cline_stream, 30, (object) (uint) Operation_Mode); cline_stream.WaitForPipeDrain(); byte[] buffer = new byte[9]; cline_stream.Read(buffer, 0, buffer.Length); return BitConverter.ToInt32(buffer, 5); })).ConfigureAwait(false); cline_stream.Close(); return output; } catch (Exception ex) { return output; } } Don’t worry if it all looks like gibberish to you, it did to me as well when I first came across it. Since i was wholly unfamiliar with the Windows API, I asked ChatGPT to explain the code to me like a 5 year old. GPT promptly explained that this function was creating something called a “Named Pipe” which is used for inter-process communication. Uh oh, this meant that the actual WMI call was was being made by a process on the receiving end of this pipe. Interestingly, I noted that the name of the pipe was ‘PredatorSense_service’, suggesting that the recipient process was a service. While we are here, let me also comment that the Operation_Mode argument of set_operation_mode() took one of three values: 0, 1 or 4. Which makes sense considering that my lapop has three performance modes. The Final Piece Of The Puzzle Sure enough, there was indeed a service in services.msc named Predator Service, the service started a program called Pssvc.exe. This particular program was written in C++, I initially used IDA to disassemble it before realizing that I had pretty much 0 knowledge of assembly ;-; That’s when I remembered Ghidra, a reversing tool developed by the NSA, that I had used during a CTF contest that I had played a long time ago. Ghidra tries its best to produce a readable C-like program from the disassembled code. After some heavy decompiling on the service file using Ghidra I finally found out that the value is read from the named pipe and then used to call a function from a function pointer table as follows: 1 (*(code *)(&PTR_LAB_140052c90)[uVar14])(puVar5,puVar8,&local_250,&local_244); Here, &PTR_LAB_140052c90 refers to the following function pointer table - If you remember from earlier, a command index of 30 was passed into the named pipe along with the Operation Mode. This index corresponds to the function pointer that I’ve highlighted in the image. I still needed to know what the arguments are for this function, here is the relevant section of the code which receives the input from the named pipe and calls this function — Yes, it’s one hell of a monstrosity—but after staring at it for a long time, I figured out that all it does is pass an array of bytes from the named pipe with their corresponding byte offsets to the function. You can observe this in the last line of code which actually performs the function call, puVar5 is the array of bytes and puVar8 are the byte offsets (I think anyways) Jackpot Finally, we are ready to analyze the function that makes the WMI call — This function dereferences the values from the byte array and performs a bitwise operation (value << 8 | 0xb;) on them before passing them to the WMI call. Doing this manually on the OperationMode values from earlier, we get the following values for WMI calls: 1 2 3 4 5 6 7 8 9 //SetGamingMiscSetting Performance: 1035 Default: 267 Quiet: 11 //SetGamingFanBehavior Custom: 12779520 Auto: 4259840 Max: 8519689 Using WMI Explorer to call this function with this values does indeed change performance profiles and fan speeds! All of this reversing had finally paid off! Or so I thought.. Writing The Patch After all of that work—reverse engineering the NitroSense app and painstakingly obtaining the correct values, I was ready to write my patch. Which is when I discovered that the kernel module, acer-wmi, which adds WMI functionality to Linux for my laptop already had all of the above values defined! 🙃 Now this truly threw me for a loop, if someone had already taken the time to reverse these values why weren’t they working on my laptop? Initially I thought this was because my turbo button was not producing a WMI event when pressed. I reached out the maintainers on the platform profile subsystem asking for help and they were more than ready to help. In fact, one of them even offered to write the patch for me! However since my main aim was to learn, I politely refused and he was kind enough to guide me in the right direction. From there, I learnt about ACPI tables where these WMI functions are defined and the corresponding tools used to read them. After scanning through the ACPI code I realized that the Predator and Nitro series of laptops share the same values for the profiles and that the core issue was that the Predator series supports two additional profiles. The acer_wmi module had the supported_profiles value hardcoded for the Predator. However, it should have been set dynamically, since the hardware had another WMI call (GetGamingMiscSetting) that returns a bitmap indicating the supported performance profiles. This function was simply not being utilised by the current driver. Hence, my patchset essentially involved adding dynamic support for setting the supported platform profiles and some other miscellaneous improvements to the platform profile handling for acer laptops. After these patches got merged, I could finally set my performance profiles from the sysfs interface at /sys/firmware/acpi/platform_profile! We weren’t done yet though. One last issue I was facing is that on Windows, my CPU was able to reach its max thermal limit of 100°C when operating in performance mode but on Linux, it was throttling at 92°C. I initially tried tweaking CPU frequency scaling drivers and other settings without success. After a lot of trial and error, a maintainer suggested installing thermald—and that ended up solving the problem! Conclusion That just about does it, in this rather wordy blog post I’ve written down (almost) my complete approach to adding some unsupported functionality for my hardware to the Linux Kernel. Have to say, while it was certainly frustrating at times, it was a great deal of fun. Rarely do you actually get to go down to the basics like ACPI tables or manually juggle bitmasks to solve problems with your laptop. It’s hard to explain but there is a sort of raw simplicity operating at such a low level, everything merely does what its meant to do and it does it well. There’s no hidden abstractions or sneaky gotcha’s that surprise you. Going through this whole process also made me realize that you can literally solve any problem you have with software, as long as you have the grit to stick with it and see it through. https://quantumloom.in/blog/resupplyfi-vault-exploit https://quantumloom.in/blog/resupplyfi-vault-exploit Sun, 20 Jul 2025 00:00:00 GMT Shashank Amireddy ERC-4626 + empty vault = disaster waiting to be donated. https://astro-erudite.vercel.app/blog/letterboxd/ https://astro-erudite.vercel.app/blog/letterboxd/ Sat, 12 Jul 2025 00:00:00 GMT K Arhant This post highlights why stopped enjoying letterboxd https://nithitsuki.com/posts/sysprompt.nithitsuki.com/ https://nithitsuki.com/posts/sysprompt.nithitsuki.com/ Thu, 10 Jul 2025 00:00:00 GMT Nithilan Rameshkumar use AI to improve yourself, not to degrade your cognitive abilities https://namishh.com/blog/talks/slow-and-curious https://namishh.com/blog/talks/slow-and-curious Mon, 23 Jun 2025 00:00:00 GMT Namish Pande Read more about this content https://heftymouse.me/blog/raytracer/ https://heftymouse.me/blog/raytracer/ Tue, 17 Jun 2025 00:00:00 GMT Nikhil Bharadwaj RTX On. https://adithyanair.com/blog/new-design/ https://adithyanair.com/blog/new-design/ Wed, 04 Jun 2025 00:00:00 GMT Adithya Nair The new design of my website, and the motivation behind it. https://quantumloom.in/blog/from-exploit-to-escape https://quantumloom.in/blog/from-exploit-to-escape Mon, 26 May 2025 00:00:00 GMT Shashank Amireddy Bybit’s Multisig Was Secure—Until the UI Wasn’t https://namishh.com/blog/devlogs/planet https://namishh.com/blog/devlogs/planet Mon, 14 Apr 2025 00:00:00 GMT Namish Pande Read more about this content https://irregular25.in/posts/injured-android/solution/ https://irregular25.in/posts/injured-android/solution/ Thu, 10 Apr 2025 00:00:00 GMT Archishman Ghosh My writeups for the Injured Android series https://namishh.com/journal/2025-04-01 https://namishh.com/journal/2025-04-01 Tue, 01 Apr 2025 00:00:00 GMT Namish Pande nothing but just my conscious stream put into words https://compileartisan.dev/blog/paste-cat/ https://compileartisan.dev/blog/paste-cat/ Sun, 16 Mar 2025 00:00:00 GMT Praanesh Nair How uniqueness and inspiration met in my workflow https://hrideshmg.com/p/arcane/ https://hrideshmg.com/p/arcane/ Fri, 14 Mar 2025 00:00:00 GMT Hridesh MG You ever just sit down after finishing a show, having this indescribable void inside you that you know can’t be filled anytime soon? This was me at 2 AM yesterday after finishing Arcane. I can’t quite put my finger on what the cause is — is it the realization that there aren’t any more episodes? or the fact that this world that you grew so connected to has suddenly ceased to exist? Whatever it is, that void is still here and maybe that’s okay. Some stories don’t really end, they just leave a piece behind with you. The last time I felt like this was after finishing the 1995 classic Neon Genesis Evangelion, a show that is still, to this day, very close to my heart. This blog post isn’t really meant to be an exhaustive analysis of the show, rather, it’s just a personal reflection of some of the elements that I loved about it. The Animation I don’t think this is a field which needs much introduction, Arcane has over 16 accolades for animation from various award ceremonies. One thing that really stood out to me in season 2 was the emphasis on the facial expressions of the characters. Paraphrasing a comment I saw on reddit — It actually felt like they were acting, 3D models, acting! You can see the pain, hesitation and trauma written all over their faces. Their pupils dilate and their eyes glisten depending on the scenes the characters are in. Fortiche have pretty much cemented themselves as pioneers with their distinctive style and attention to detail and I’m pretty excited to see what comes out of this studio next. The Characters/Writing This is where the brilliance of the show really shines through. I could personally connect and empathize with a lot of characters in the show, their arcs are meaningful and full of emotion. Almost each and every character in the show has flaws in one way or another and they all try to overcome their pain and trauma in distinct ways. There’s this rawness to the way the show explores themes like revenge, betrayal, abandonment, family, loss etc. The writers really don’t pull their punches here, so don’t be surprised if a character you really like ends up in the casket a few episodes down. It also helps that the show religiously follows the rule of 3. Each season is composed of 9 episodes each with every 3 episodes forming an act. Each act moves the story forward in a significant and intentional way. The end result of this is that no episode really feels like filler, because all of them serve a specific purpose in their respective acts. Everything has weight and by the time you reach the end of an act, it feels like you’ve completed a movie by itself. The Music/Sound Design Arcane has hands down one of the best sound design I’ve seen in any animated show ever, an incredible amount of detail has gone into making sure the world feels real. Every punch, object falling, weapon firing have this impact to them, it almost feels like you are there in the world hearing it for yourself. Do yourself a favour and watch this show with headphones on, trust me, you won’t regret it. The soundtrack is also out of this world, the songs really do take impactful scenes to the next level by amplifying the emotions on display in each scene. I read somewhere that each song was custom made for the show and it shows. I’ve been replaying “Ma Meilleure Ennemie” from episode 8 of season 2 nonstop and the way they integrated it with the scene was impeccable. It kind of reminds me of the ending song of Cyberpunk: Edgerunners - “I Really Want to Stay at Your House”. I’d like to keep this review spoiler free but if you know, you know :) Music when done right is actually one of my favourite aspects of media whether it be shows, movies or games for the simple reason that listening to a song can evoke the same emotion that you felt while actually experiencing the story for the first time. The World Building As someone who hasn’t really played the game much or has read any of the lore. The writers definitely managed to make the land of Piltover (and Runeterra in general) feel alive. I will always say that first and foremost, Arcane is a show about the characters but they have put a lot of work into the technical aspects as well. (Minor Spoilers!) Even exploring concepts like time travel and parallel dimensions. Sadly, it did feel a bit rushed at times, particularly during S2, but its understandable considering that they wanted to finish the story in two seasons. Conclusion I have to say, I do feel a bit spoiled after watching this show. It’s not everyday that you come across a piece of art that has had this much love and attention to detail put into it. Don’t let the fact that its an animated show put you off, you would be missing out on one of the finest shows produced in this decade (maybe more). https://heftymouse.me/updates/3/ https://heftymouse.me/updates/3/ Sun, 09 Mar 2025 00:00:00 GMT Nikhil Bharadwaj More new information let's go https://hrideshmg.com/p/lfx-mentorship/ https://hrideshmg.com/p/lfx-mentorship/ Sat, 08 Mar 2025 00:00:00 GMT Hridesh MG This blog post has been long overdue but I’ve finally gotten around to it! I graduated from the Linux Kernel Bug Fixing Mentorship Programme'25 sometime in late january. I’ll be detailing my experience about the same in this blog post. What is the LKMP? The Linux Kernel Mentorship programme or LKMP for short is, as written on their website - “A structured remote learning opportunity for aspiring Linux Kernel developers” In specific, the programme that I was part of was the Linux Kernel Bug Fixing Programme but don’t let the name fool you, you can do a lot more than just fix bugs, like writing new device drivers or extending existing ones. In short, its an opportunity where beginners to kernel dev can get their feet wet with the Linux Kernel while being supported by experienced mentors. Note that unlike GSoC or traditional LFX mentorships, the kernel bug fixing mentorship is an unpaid one but the knowledge you get from the whole process is worth its weight in gold. If, however, you’re someone who needs a little more motivation than that then you should probably look elsewhere as you can only ever do one LFX mentorship during your lifetime. Choose wisely :) The structure of the program I would say that the LKMP is a very flexible program in the sense that there is no roadmap or particular set of tasks that you have to complete in order to graduate. You are free to make any kind of meaningful contribution to the kernel, this opens the door to work on anything that you’re truly interested in. This coupled with the fact that you get to attend weekly meetings with experienced kernel developers makes it a very enriching experience. The only requirements for graduation is that you need to have around 5-10 patches accepted into the Linux Kernel by the end of the program. This might seem difficult at the start, but trust me, once you get into the flow of things, it becomes a breeze. Why I decided to join the programme There’s actually a bit of an interesting backstory behind this, when I first bought my laptop (an Acer Nitro 5) and installed Linux on it ( as one does with a brand new PC, obviously ) I noticed that no matter what I tried, I just could not get the headphone jack to detect the microphone. This is an issue that I had revisisted multiple times over the course of a year and it had even persisted across distros! This led me to believe that the issue was in the kernel and sure enough, after a bit of research this had been the case. Around this time a few of my club seniors suggested me to try out the LFX mentorship since I wanted to explore low level development and I figured that it was the perfect opportunity to try and fix this tiny (but very annoying!) problem. As Plato once said - “Necessity is the mother of invention” – Plato My contributions Fixing microphone input on the ALC287 Codec After a bit of research, I stumbled upon this excellent blog post by Luke Jones on his adventure for getting sound to work on Asus ROG notebook. If it were not for this resource, this journey would have been much, much longer. Through his blog I understood a lot of fundamentals regarding how audio is handled for Realtek Codecs on Linux but wait a minute Hridesh, what on earth is a Codec? Let me explain it with the help of an image - As you can see the Codec is a hardware chip on the motherboard which is responsible for controlling the speakers and microphone on the system. The kernel interacts with this chip using the I2C interface, but we don’t need to go that deep to fix our issue. The problem that occurs here is that this codec expects the software to interact with it in a certain manner. However, Realtek, in all their glory, often ship these chips with non-standard configurations, meaning they don’t always properly report their capabilities to the operating system. Instead, they rely on driver-specific quirks to function correctly. The issue is that these quirks are only implemented in the Windows driver, leaving Linux users to manually patch or configure the kernel to get everything working. The result of this? A giant file in the kernel tree named patch_realtek.c which has (at the time of writing) over 13,000 lines of patches for various different codecs. After digging a bit deeper into it and experimenting a bit, I finally got it to work after reverse engineering the windows driver and figuring out which quirk was missing! This was my reaction after finally see the mic input meter start moving - Apparently, the quirk that I had found out was already defined in the patch_realtek file, so all I had to do was map it to my codec. I quickly made a patch and submitted it and it finally got released in v6.13 of the kernel. This means that everyone who has my laptop or uses the same audio codec can finally enjoy working microphone input. Enabling Turbo support on my laptop The second contribution is the one I spent the most amount of time on and it’s where I realized how awesome the kernel community really is. My laptop is a gaming laptop and gaming laptops often have this feature where you can activate certain profiles like “performance” or “quiet”. These profiles enable you to extract more power from your machine by overclocking the CPU/GPU or tell it to slow down the fans so that it runs more quietly. However, these profiles are only accessible on Windows through the dedicated vendor app. I was initially skeptical as to whether it was even possible to bring this support to Linux, which prompted me to send an email to the kernel mailing list asking for help. The developers there were extremely supportive and they even offered to write the patch for me! However, since I wanted to learn and tinker with it, I endeavoured to try and implement it myself. Through the process, I learnt about a variety of different things like ACPI tables, WMI calls, sysfs interfaces, and even did some indepth reverse-engineering using Ghidra and dotPeek to find out how the Windows app worked underneath the hood. A full technical write up on this would warrant another blog post, so keep an eye out for that The blog post for it is now out :) My experience The LKMP has been one of the most impactful programs that I’ve participated in. You might find this surprising, but the majority of kernel developers aren’t actually paid for their work, they do everything voluntarily and their enthusiasm is nothing short of infectious. Taking part in this whole process really taught me a lot, the kernel community has very high standards when it comes to code quality. I’ve had maintainers painstakingly take apart each line in my patch to suggest improvements and question logic but don’t be scared of this! In fact, this level of scrutiny is what makes the kernel so robust. Every comment from a maintainer is an opportunity to learn, not just about kernel code but about writing efficient, clean and maintainable code. I feel like the way I approach code has fundamentally changed after taking part in the LKMP. For starters, I’ve become much more conscious of the changes that I make and running git diff to verify my logic before every commit has pretty much become second nature to me. Debugging issues in a codebase as large and complex as the Linux Kernel has also given me the confidence that if I put my mind to it, I can tackle any problem, no matter how large it may seem. It wouldn’t be an exaggeration to say that I’ve improved significantly as a developer after completing the programme. Conclusion I think I’ll just end this post by saying that if you’ve been meaning to explore kernel development or just become a better developer overall, the LKMP is a fantastic opportunity. The learning curve might be a bit steep, but as they say - “Its the hard things in life that are worth doing.” Here is a link where you can check out all of my contributions to the kernel: https://web.git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/log/?qt=author&q=hridesh https://hrideshmg.com/p/silence/ https://hrideshmg.com/p/silence/ Sun, 16 Feb 2025 00:00:00 GMT Hridesh MG I sit here in the darkness, my laptop wide open, the gentle hum of the ceiling fan and the rhythmic pulse of the led on the wifi router my only companion. There is no sound, except the one within my mind. Thoughts as they are - floating about, colliding and colluding, such is the nature of existence. Sound may very well be the antithesis of introspection, for quiet retreat is a tough thing to find in this noisy and bustling world. Yet, I wish it more common. The external silence only serves to amplify the internal chaos; yet, without it, one wouldn’t even realize the disarray within. https://hrideshmg.com/p/hello-world/ https://hrideshmg.com/p/hello-world/ Thu, 13 Feb 2025 00:00:00 GMT Hridesh MG A bit about myself Hey there I’m Hridesh MG and welcome to my little space on the interwebs. I’m a sophomore student pursuing Computer Science Engineering at Amrita University. I’ve been meaning to make this blog for a while now but only got around to doing it recently. I’m quite passionate about software development and actually I’m part of an open source club at my college called amFOSS. Tech is not all though, few of my other hobbies include tinkering with electronics, watching anime, playing video games, and pondering about life while gazing at the stars. That said, I’m always open to trying new things and I always like to refer to myself as a generalist, as the famous quote goes - Jack of all trades, master of none, though often better than a master of one What you can expect There’s no point in hiding it, as you could probably tell from my hobbies, I’m a huge nerd and that is going to reflect on the type of content I write as well :) Here are a few topics that you can expect to (hopefully) find on this blog soon - Technical blogs about stuff I’ve learned recently or things I find interesting. Reviews on Anime I’ve watched or Games I’ve played. Tutorials on random things that I feel deserve one. Sharing my experience on events I’ve attended/helped organize. Random jottings about life. http://rishblol.github.io/blog/2025-post/post-one/ http://rishblol.github.io/blog/2025-post/post-one/ Sun, 09 Feb 2025 00:00:00 GMT Rishabh Lal Why did I even bother making a website in the first place? https://astro-erudite.vercel.app/blog/portfolio-journey/ https://astro-erudite.vercel.app/blog/portfolio-journey/ Fri, 31 Jan 2025 00:00:00 GMT K Arhant This post highlights my journey of how I created this portfolio https://adithyanair.com/blog/history-internet/ https://adithyanair.com/blog/history-internet/ Sat, 25 Jan 2025 00:00:00 GMT Adithya Nair A small piece that I need to write out. https://ngpal.github.io/brainspace/Projects/Glide---File-transferring-app/8.-Wrapping-it-Up https://ngpal.github.io/brainspace/Projects/Glide---File-transferring-app/8.-Wrapping-it-Up Sun, 19 Jan 2025 00:00:00 GMT Nandagopal Menon Hey there! I finally got to wrapping up v1.0 of the Glide. Check out this commit and the subsequent 5 commits to see all the changes that have been made since the last log, mainly implementing the protocol I developed for the application, and ironing out some bug fixes. https://ngpal.github.io/brainspace/Projects/Glide---File-transferring-app/7.-Refactoring-Galore https://ngpal.github.io/brainspace/Projects/Glide---File-transferring-app/7.-Refactoring-Galore Wed, 15 Jan 2025 00:00:00 GMT Nandagopal Menon Hellooooo! We’re back, and today I want to reorganize and refactor some of the methods, especially on the server side. All the changes we made in the last log was a bit messy 😬. https://ngpal.github.io/brainspace/More-of-Me/Astronomy https://ngpal.github.io/brainspace/More-of-Me/Astronomy Sun, 05 Jan 2025 00:00:00 GMT Nandagopal Menon Today we’re gonna talk about my relationship with astronomy and stargazing, and how you can recognize these beautiful celestial bodies yourself. What is Astronomy? Astronomy comes from the greek words astro meaning star and -nomia meaning law or culture. https://namishh.com/blog/talks/development https://namishh.com/blog/talks/development Wed, 01 Jan 2025 00:00:00 GMT Namish Pande i love computer science https://namishh.com/poems/clockmaker https://namishh.com/poems/clockmaker Sat, 28 Dec 2024 00:00:00 GMT Namish Pande will write a description later