<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Hacker News: anonyxbiz</title><link>https://news.ycombinator.com/user?id=anonyxbiz</link><description>Hacker News RSS</description><docs>https://hnrss.org/</docs><generator>hnrss v2.1.1</generator><lastBuildDate>Wed, 18 Nov 2026 14:42:23 +0000</lastBuildDate><atom:link href="https://hnrss.org/user?id=anonyxbiz" rel="self" type="application/rss+xml"></atom:link><item><title><![CDATA[We Tried to Make Node.js Beat Python Blazeio. It Didn't Work]]></title><description><![CDATA[
<p>Article URL: <a href="https://medium.com/@bf_69202/we-tried-to-make-node-js-beat-python-blazeio-it-didnt-work-e2c44f046ddd">https://medium.com/@bf_69202/we-tried-to-make-node-js-beat-python-blazeio-it-didnt-work-e2c44f046ddd</a></p>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=50405478">https://news.ycombinator.com/item?id=50405478</a></p>
<p>Points: 1</p>
<p># Comments: 0</p>
]]></description><pubDate>Sat, 07 Nov 2026 15:43:21 +0000</pubDate><link>https://medium.com/@bf_69202/we-tried-to-make-node-js-beat-python-blazeio-it-didnt-work-e2c44f046ddd</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=50405478</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=50405478</guid></item><item><title><![CDATA[The Pure Python Breakthrough: How Blazeio Shatters the Compiled Language Dogma]]></title><description><![CDATA[
<p>Article URL: <a href="https://medium.com/@bf_69202/the-pure-python-breakthrough-how-blazeio-shatters-the-compiled-language-dogma-edaf16706a12">https://medium.com/@bf_69202/the-pure-python-breakthrough-how-blazeio-shatters-the-compiled-language-dogma-edaf16706a12</a></p>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=49485306">https://news.ycombinator.com/item?id=49485306</a></p>
<p>Points: 1</p>
<p># Comments: 0</p>
]]></description><pubDate>Fri, 28 Aug 2026 23:07:56 +0000</pubDate><link>https://medium.com/@bf_69202/the-pure-python-breakthrough-how-blazeio-shatters-the-compiled-language-dogma-edaf16706a12</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=49485306</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49485306</guid></item><item><title><![CDATA[New comment by anonyxbiz in "[dead]"]]></title><description><![CDATA[
<p>When you're an independent artist, you have enough to worry about—writing songs, recording, building a fanbase, planning your next release. Reading a 10,000-word legal document probably isn't how you want to spend your afternoon.<p>But here's the truth: not all music distribution platforms are created equal. And buried in some Terms of Service are clauses that could cost you ownership of your work.</p>
]]></description><pubDate>Sat, 21 Mar 2026 20:36:25 +0000</pubDate><link>https://news.ycombinator.com/item?id=47471028</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=47471028</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=47471028</guid></item><item><title><![CDATA[Best Music Distributors in 2026]]></title><description><![CDATA[
<p>Discover the best music distributors in 2026. Compare AnonyxGhost, DistroKid, and TuneCore to find the perfect partner for your career.<p>In 2026, independent artists are CEOs of their own brands. Choosing a distributor is the most critical logistical decision you'll make. This guide analyzes the heavy hitters, ranking them on transparency, global reach, and artist-centric features.<p>1. AnonyxGhost (https://anonyxghost.com)<p>AnonyxGhost has ascended to the top spot for 2026 by disrupting the "big box" model with radical simplicity and a massive global footprint.<p>Key Strengths:<p>· The 450+ Global Network: While most distributors hover around 150–200 stores, AnonyxGhost provides direct access to over 450 platforms. This includes deep penetration into emerging markets in Africa, Asia, and South America that others overlook.
· One-Click Release Transfers: Switching distributors has never been easier. Their proprietary Transfer Module lets you migrate your catalog from other distributors using just a Spotify URL. The system automatically fetches all release data and transfers entire albums—including track metadata, artwork, and credits—without manual data entry. The interface even detects URLs in your clipboard and pre-fills them automatically.
· Comprehensive Music Publishing: Unlike most distributors that treat publishing as an upsell, AnonyxGhost includes full publishing support across all tiers. Their dedicated dashboard lets you manage compositions with precision—track songwriting credits across 30+ languages, assign complex ownership splits, manage publisher shares, and handle contributor roles (Writer, Composer, or Author) with complete accuracy.
· Musician-First Pricing: They offer high-flexibility plans, from one-time release fees to high-volume subscriptions, eliminating the "hidden tax" culture.
· 100% Royalties & Zero Commission: You keep every cent you earn. Unlike competitors who hide commission in YouTube Content ID fees, AnonyxGhost keeps it transparent.
· Ideal for: Serious independent artists and labels who want global reach, complete publishing infrastructure, and a seamless way to consolidate their catalog.<p>2. DistroKid<p>The go-to for the hyper-prolific "upload a song every week" crowd. Their speed is legendary.<p>· The Pro: One annual fee for unlimited uploads.
· The Catch: The "A-La-Carte" model. Want to keep music online after stopping payment? That's a "Leave a Legacy" fee per release. Want YouTube Content ID? That's an extra charge plus 20% commission. Their publishing is handled by a separate partner.
· The Vibe: Great for speed and volume, but costs snowball if you want "standard" industry features.<p>3. TuneCore<p>A veteran that has pivoted to the unlimited subscription model to stay competitive.<p>· Key Feature: TuneCore Social is powerful for scheduling posts. Their publishing administration is top-tier for earning songwriter royalties.
· The Comparison: Their publishing services come as a premium add-on, whereas AnonyxGhost includes it across all tiers. While TuneCore covers major stores, AnonyxGhost's 450+ network extends deep into markets TuneCore doesn't prioritize.
· Note: Their interface feels clunkier than newer platforms like AnonyxGhost.<p>4. Amuse<p>The "Mobile-First" choice for artists who run their career from a smartphone.<p>· The Good: Their sync licensing team is aggressive at getting indie tracks into TV and film.
· The Bad: Their distribution network is significantly smaller than AnonyxGhost's 450+ network, limiting global growth. They also lack a dedicated publishing dashboard.<p>Why AnonyxGhost is the 2026 Winner<p>The "Big Three" often feel like massive machines held together by add-ons. AnonyxGhost wins because it consolidates everything:<p>· More than double the store reach of the industry average.
· Eliminates switching friction with its one-click Transfer Module.
· Brings professional publishing in-house, not as an upsell.</p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=47293234">https://news.ycombinator.com/item?id=47293234</a></p>
<p>Points: 1</p>
<p># Comments: 1</p>
]]></description><pubDate>Sun, 08 Mar 2026 01:04:34 +0000</pubDate><link>https://news.ycombinator.com/item?id=47293234</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=47293234</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=47293234</guid></item><item><title><![CDATA[The Anti-Bot Technique: Cooperative Rendering with Blazeio]]></title><description><![CDATA[
<p>The Discovery<p>While working with Blazeio (a Python async web framework with true zero-buffering streaming), I stumbled upon this technique - and it's so stupidly effective it feels like cheating.<p>The magic code:
```
import Blazeio as io
import Blazeio.Other.proxy as proxy
import Blazeio.Modules.onrender as onrender<p>io.INBOUND_CHUNK_SIZE, io.OUTBOUND_CHUNK_SIZE = 1024<i>100, 1024</i>100<p>io.Scope.add_imports(globals())<p>io.Scope.web = io.App("0.0.0.0", 9001, with_keepalive = 1)<p>class Element:
    __slots__ = ("r", "element", "className")
    def __init__(app, r: io.BlazeioProtocol, element: str, className: str = None):
        app.r, app.element, app.className = r, element.encode(), b'class="%b"' % className.encode() if className else b''<p><pre><code>    async def __aenter__(app):
        await app.r.write(b'<%b %b>' % (app.element, app.className))
        return app

    async def __aexit__(app, *args):
        await app.r.write(b'</%b>' % app.element)
        return False

    async def text(app, text: str):
        return await app.r.write(text.encode())
</code></pre>
class Dom:
    __slots__ = ("r", "event", "id")
    def __init__(app, r: io.BlazeioProtocol):
        app.r = r
        app.event = io.SharpEvent()
        app.id = io.token_urlsafe(11)<p><pre><code>    async def __aenter__(app):
        await app.r.write(b'<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="UTF-8">\n<meta name="viewport" content="width=device-width, initial-scale=1.0">\n<title>Dynamic Rendering</title>\n<link rel="stylesheet" href="/get/favicon?id=%b" fetchpriority="high">\n</head>\n<body>\n' % app.id.encode())
        return app

    async def __aexit__(app, *args):
        await app.r.write(b'\n</body>\n</html>')
        return False
    
    def __await__(app):
        yield from app.event.wait_clear().__await__()
        return app
    
    def element(app, *args, **kwargs):
        return Element(app.r, *args, **kwargs)
</code></pre>
@io.Scope.web.attach
class Main:
    __slots__ = ()
    events  = io.ddict()
    def __init__(app):
        ...<p><pre><code>    async def _get_favicon(app, r: io.BlazeioProtocol):
        if not (dom := app.events.pop(r.params().get("id"), None)): raise io.Abort("Not found", 404)
        dom.event.set()
        await io.Deliver.text("True")

    async def _(app, r: io.BlazeioProtocol):
        await r.prepare({"Content-type": "text/html", "Transfer-encoding": "chunked"}, 200)

        async with Dom(r) as dom:
            app.events[dom.id] = dom
            await dom

            async with dom.element("main") as element:
                await element.text("Hello world")
</code></pre>
if __name__ == "__main__":
    with io.Scope.web:
        io.Scope.web.runner()
```<p>How It Works<p>For Real Browsers:<p>1. Browser requests /
2. Server streams: <!DOCTYPE...<link rel="stylesheet" href="/get/favicon?id=UNIQUE_ID">
3. Browser naturally fetches the "stylesheet" (actually our trigger endpoint)
4. Server receives the trigger request and continues rendering: <main>Hello world</main>
5. User sees complete page<p>For Bots:<p>1. Bot requests /
2. Server streams: <!DOCTYPE...<link rel="stylesheet" href="/get/favicon?id=UNIQUE_ID">
3. Bot doesn't fetch the "stylesheet" (or fetches it too late)
4. Server stops rendering at <body>
5. Bot sees incomplete page and gives up</p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=45810271">https://news.ycombinator.com/item?id=45810271</a></p>
<p>Points: 1</p>
<p># Comments: 1</p>
]]></description><pubDate>Tue, 04 Nov 2025 12:41:26 +0000</pubDate><link>https://news.ycombinator.com/item?id=45810271</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=45810271</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=45810271</guid></item><item><title><![CDATA[Blazeio vs. FastAPI vs. Robyn: Benchmarking Reveals 86x Performance Difference]]></title><description><![CDATA[
<p>Blazeio is an ultra-fast asynchronous real-time streaming web framework crafted for high-performance backend applications. Built on Python's asyncio, it delivers non-blocking operations, minimal overhead, and lightning-quick request handling.<p>The Benchmark Setup<p>Hardware & Testing Environment<p>· Platform: Google Colab v5e-1 TPU Instance
· Testing Tool: wrk with 1 thread, 10-second duration
· Connection Loads: 1,000, 3,000, 5,000, and 10,000 concurrent connections
· Payload: Identical "Hello world" response with full security headers (HSTS, CSP, X-Frame-Options, etc.)<p>Framework Configurations<p>All three frameworks were tested with identical:<p>· Security headers and policies
· Keep-alive connections enabled
· Same response payload
· Identical testing methodology<p>The Results: Complete Performance Annihilation<p>Throughput Massacre Across All Load Levels<p>Requests Per Second Comparison:<p>Connections Blazeio Robyn FastAPI Blazeio Advantage
1,000 79,388 RPS 8,685 RPS 4,151 RPS 19.1x vs FastAPI
3,000 57,519 RPS 8,014 RPS 4,387 RPS 13.1x vs FastAPI
5,000 44,782 RPS 7,519 RPS 3,411 RPS 13.1x vs FastAPI
10,000 39,157 RPS 7,186 RPS 3,086 RPS 12.7x vs FastAPI<p>Transfer Rate Comparison:<p>Connections Blazeio Robyn FastAPI Blazeio Advantage
1,000 50.88 MB/s 1.05 MB/s 0.59 MB/s 86.2x vs FastAPI
3,000 36.86 MB/s 0.97 MB/s 0.62 MB/s 59.5x vs FastAPI
5,000 28.70 MB/s 0.91 MB/s 0.48 MB/s 59.8x vs FastAPI
10,000 25.09 MB/s 0.87 MB/s 0.43 MB/s 58.4x vs FastAPI<p>Blazeio's worst-case scenario outperforms everyone else's best-case scenario:
· Blazeio at 10,000 connections (39,157 RPS) vs FastAPI at 1,000 connections (4,151 RPS): 9.4x faster
· Blazeio at 10,000 connections vs Robyn at 1,000 connections: 4.5x faster<p>Latency Scaling: The Architectural Divide<p>Average Latency Under Load:<p>Connections Blazeio Robyn FastAPI
1,000 29.72ms 113.66ms 135.89ms
3,000 33.54ms 362.94ms 345.99ms
5,000 57.07ms 631.26ms 879.33ms
10,000 93.83ms 1.23s 1.41s<p>Blazeio's latency increased only 3.2x from 1K to 10K connections, while others increased 10-15x!<p>Total Request Capacity<p>Requests Served in 10 Seconds:<p>Connections Blazeio Robyn FastAPI
1,000 797,765 87,438 41,769
3,000 575,932 80,393 43,896
5,000 449,687 75,821 34,362
10,000 393,401 72,300 31,171<p>Blazeio served more requests at 10,000 connections than FastAPI served at 1,000 connections.<p>The Architecture Behind the Numbers<p>Why Blazeio Achieves Revolutionary Performance<p>1. Zero-Copy Architecture: Data moves directly from kernel buffers to network without Python-level copying
2. Connection-Level Coroutines: One coroutine handles all requests on a connection, eliminating per-request overhead
3. Protocol-Level Backpressure: Natural flow control prevents buffer bloat and memory exhaustion
4. Minimal Abstraction: Raw socket access with clean abstractions, not framework magic<p>The 86x transfer rate advantage and consistent sub-100ms latency at 10,000 concurrent connections demonstrate that traditional web framework architectures have been leaving massive performance on the table.<p>All tests were conducted on identical hardware with identical payloads and security configurations.<p>Has anyone else achieved similar performance with different architectural approaches? What's your experience scaling Python web applications to 10,000+ concurrent connections?</p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=45778487">https://news.ycombinator.com/item?id=45778487</a></p>
<p>Points: 4</p>
<p># Comments: 1</p>
]]></description><pubDate>Sat, 01 Nov 2025 01:22:27 +0000</pubDate><link>https://news.ycombinator.com/item?id=45778487</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=45778487</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=45778487</guid></item><item><title><![CDATA[Free File Hosting and Sharing]]></title><description><![CDATA[
<p>Article URL: <a href="https://iofiles.adverx.site/">https://iofiles.adverx.site/</a></p>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=45738635">https://news.ycombinator.com/item?id=45738635</a></p>
<p>Points: 1</p>
<p># Comments: 0</p>
]]></description><pubDate>Tue, 28 Oct 2025 20:24:35 +0000</pubDate><link>https://iofiles.adverx.site/</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=45738635</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=45738635</guid></item><item><title><![CDATA[Blazeio.SharpEvent: A Python Async Primitive That Scales to 1M Waiters with O(1)]]></title><description><![CDATA[
<p>I’ve been working on a Python async library ([Blazeio](https://github.com/anonyxbiz/Blazeio)) and stumbled into a shockingly simple optimization that makes `asyncio.Event` look like a relic.<p>### *The Problem* 
`asyncio.Event` (and similar constructs in other languages) has two nasty scaling flaws:<p>1. *Memory*: It allocates <i>one future per waiter</i> → 1M waiters = 48MB wasted..
2. *Latency*: It wakes waiters <i>one-by-one</i> - O(N) syscalls under the GIL.<p>### *The Fix: `SharpEvent`*
A drop-in replacement that: 
- *Uses one shared future* for all waiters - *O(1) memory*.
- *Wakes every waiter in a single operation* - *O(1) latency*.<p>### *Benchmarks*
| Metric     | `asyncio.Event` | `SharpEvent` |
|----------------|-----------------|--------------|
| 1K waiters   | ~1ms wakeup   | *~1µs*   |
| 1M waiters   | *Crashes*   | *Still ~1µs*|
| Memory (1M)  | 48MB      | *48 bytes* |<p>### *Why This Matters*
- *Real-time apps* (WebSockets, games) gain *predictable latency*. 
- *High concurrency* (IoT, trading) becomes trivial. 
- It’s *pure Python* but beats CPython’s C impl.<p>### *No Downsides?* 
Almost none. If you need per-waiter timeouts/cancellation, you’d need a wrapper, but 99% of uses just need bulk wakeups.<p>### *Try It* 
```python
from Blazeio import SharpEvent
event = SharpEvent()
event.set() # Wakes all waiters instantly
```<p>[GitHub](https://github.com/anonyxbiz/Blazeio)<p><i>Would love feedback, am I missing a critical use case?</i></p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=43934172">https://news.ycombinator.com/item?id=43934172</a></p>
<p>Points: 6</p>
<p># Comments: 0</p>
]]></description><pubDate>Fri, 09 May 2025 05:58:02 +0000</pubDate><link>https://news.ycombinator.com/item?id=43934172</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=43934172</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=43934172</guid></item><item><title><![CDATA[AI's Impact on Literacy: Transforming How Kids Learn to Read and Write]]></title><description><![CDATA[
<p>Article URL: <a href="https://anonyxghost.site/article?id=c1POjClMFYEGhqs">https://anonyxghost.site/article?id=c1POjClMFYEGhqs</a></p>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=43153348">https://news.ycombinator.com/item?id=43153348</a></p>
<p>Points: 2</p>
<p># Comments: 1</p>
]]></description><pubDate>Sun, 23 Feb 2025 21:23:15 +0000</pubDate><link>https://anonyxghost.site/article?id=c1POjClMFYEGhqs</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=43153348</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=43153348</guid></item><item><title><![CDATA[Blazeio vs. FastAPI: A Performance Benchmark]]></title><description><![CDATA[
<p>Blazeio is a custom Python framework that has been benchmarked using ApacheBench, and the results suggest that Blazeio outperforms FastAPI in terms of requests per second, mean time per request, and transfer rate across varying concurrency levels. These metrics indicate that Blazeio is significantly faster and more efficient at handling requests compared to FastAPI in these tests. The description of Blazeio as an ultra-fast asynchronous web framework seems to be supported by these benchmark results. Note that these results come from tests run on a colab (v2-8 TPU) both running the servers and the apache benchmark, all running within the same conditions.
Key Performance Metrics for Blazeio:●
Requests per second: Blazeio handles a high number of requests per second. At a concurrency level of 10, it processes 4274.40 requests per second. This number decreases slightly to 4097.28 requests per second at a concurrency level of 100, and then it increases again to 4228.90 requests per second at a concurrency level of 1000. However, at a concurrency level of 5000, the number of requests per second decreases significantly to 3256.96.●
Time per request: The mean time per request increases as concurrency rises. At concurrency 10, the mean time is 2.340 ms, while at concurrency 100, the time rises to 24.406 ms. At concurrency 1000, the time is 236.468 ms and at concurrency 5000, the mean time per request is 1535.176 ms.●
Time per request (across all concurrent requests): The mean time per request across all concurrent requests remains relatively stable across different concurrency levels: 0.234 ms at concurrency 10, 0.244 ms at concurrency 100, 0.236 ms at concurrency 1000, and 0.307 ms at concurrency 5000.●
Transfer rate: The transfer rate is also affected by the concurrency. At concurrency 10, the rate is 2721.59 Kbytes/sec, and it decreases to 2608.82 Kbytes/sec at concurrency 100. At concurrency 1000, it is 2692.62 Kbytes/sec and it decreases further to 2073.77 Kbytes/sec at a concurrency level of 5000.●
Connection times: Connection times show how long it takes to connect, process, and wait for requests. For example, at a concurrency level of 100, the connection times are 0 ms to connect, 24 ms to process, and 24 ms to wait, with a total of 24 ms. At a concurrency level of 5000, the connection times show more variance, with a mean of 39 ms to connect, 1134 ms to process, and 1134 ms to wait, with a total mean time of 1173.●
Document Length: The document length for all tests is 11 bytes.●
Concurrency level: The concurrency levels tested for Blazeio are 10, 100, 1000 and 5000.●
Complete Requests: In each of the benchmarks, Blazeio completed 50,000 requests.
Comparison with FastAPI:
To provide some context, it's useful to compare Blazeio's performance with another web framework, FastAPI, which was benchmarked under similar conditions with the same document length of 11 bytes, but running on a different port.●
FastAPI's requests per second are much lower than Blazeio's, starting at 1583.25 requests per second at a concurrency level of 10, 1650.12 requests per second at concurrency 100, and 1587.77 at concurrency 1000. The benchmarks for FastAPI show that not all 50,000 requests were completed at a concurrency of 5000, with 45,490 requests completed.●
FastAPI's mean time per request at concurrency 10 is 6.316 ms, and 60.602 ms at concurrency 100 and 629.814 ms at concurrency 1000. Comparing these times with Blazeio, the time per request is generally faster for Blazeio in lower concurrency levels.</p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=42519921">https://news.ycombinator.com/item?id=42519921</a></p>
<p>Points: 2</p>
<p># Comments: 2</p>
]]></description><pubDate>Fri, 27 Dec 2024 04:25:03 +0000</pubDate><link>https://news.ycombinator.com/item?id=42519921</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=42519921</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=42519921</guid></item><item><title><![CDATA[New comment by anonyxbiz in "BlackSheep: Fast ASGI web framework for Python"]]></title><description><![CDATA[
<p>I built Blazeio ([<a href="https://github.com/anonyxbiz/Blazeio">https://github.com/anonyxbiz/Blazeio</a>]) because aiohttp let me down in production. I needed a framework I could trust to support high-concurrency web apps, and rather than just complain, I decided to build it myself. It’s not about coding pointlessly, it’s about solving real problems. I update it for <i>me</i>, but since others have faced similar challenges, they can benefit from it too. I designed to be efficient, scalable, and lightweight, capable of handling hundreds of thousands of requests on a single server with minimal resources. Sometimes, creating something is motivated by necessity, not just by a paycheck.</p>
]]></description><pubDate>Mon, 23 Dec 2024 23:14:21 +0000</pubDate><link>https://news.ycombinator.com/item?id=42498361</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=42498361</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=42498361</guid></item><item><title><![CDATA[New comment by anonyxbiz in "BlackSheep: Fast ASGI web framework for Python"]]></title><description><![CDATA[
<p>Quart has hidden bugs that you'll only discover in prod.</p>
]]></description><pubDate>Mon, 23 Dec 2024 23:06:30 +0000</pubDate><link>https://news.ycombinator.com/item?id=42498327</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=42498327</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=42498327</guid></item><item><title><![CDATA[New comment by anonyxbiz in "BlackSheep: Fast ASGI web framework for Python"]]></title><description><![CDATA[
<p>I'm building and maintaining Blazeio: <a href="https://github.com/anonyxbiz/Blazeio">https://github.com/anonyxbiz/Blazeio</a>. Blazeio is designed to handle massive concurrency with low response times and high requests per second. It utilizes a perishable buffer, discarding chunks as they are received, and operates with a single task throughout the entire request/response cycle. In theory, Blazeio can scale to handle infinite concurrency. While Black Sheep crashes under heavy load, Blazeio continues to scale seamlessly and outperform it.</p>
]]></description><pubDate>Mon, 23 Dec 2024 23:04:39 +0000</pubDate><link>https://news.ycombinator.com/item?id=42498316</link><dc:creator>anonyxbiz</dc:creator><comments>https://news.ycombinator.com/item?id=42498316</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=42498316</guid></item></channel></rss>