{"slug": "pyronaut-pyronaut-blog", "title": "Pyronaut – Pyronaut Blog", "summary": "Pyronaut launched as a high-performance Python application platform built on GraalVM and Micronaut, fusing the Python AST with the Java compiler and serving Python code through Micronaut's Netty-based HTTP server. The company reported benchmarks of 2.6 times the throughput of FastAPI and 6.5 times that of Flask at lower latency, with native async/await wired directly into the Netty event loop and streaming support for SSE and websockets via async generators. Developers run applications with the commands \"pyronaut dev main.py\" and \"pyronaut run main.py\".", "body_md": "[← Blog](https://pyronaut.io/blog/)\n\n# Introducing Pyronaut\n\n[Announcements](https://pyronaut.io/category/announcements/)\n\nToday we are pleased to announce the availability of [Pyronaut](https://pyronaut.io), a high-performance Python application platform for building production-ready services built on [GraalVM](https://graalvm.org) and [Micronaut](https://micronaut.io).\n\n## What is Pyronaut?\n\nPyronaut brings the same ideas and benefits of [Micronaut](https://micronaut.io) and [GraalVM](https://graalvm.org) (AOT compilation, build time validation, source code processing etc.) to Python by fusing the Python AST with the Java compiler and optimizing runtime execution with GraalVM and the Graal JIT to enable highly performant and scalable Python services.\n\nThanks to the growth of AI, Python is one of the most popular languages in the world today, and from today Python can be used on one of the most mature, scalable and popular frameworks in the JVM ecosystem. Choosing Python as your server side language no longer means reduced throughput and higher latency.\n\n## The smallest Pyronaut application\n\nCreate `main.py`:\n\n``` php\nfrom micronaut.http.annotation import Get\n\n@Get(\"/\")\ndef read_root() -> dict:\n    return {\"Hello\": \"World\"}\n\n@Get(\"/items/{item_id}\")\ndef read_item(item_id: int, q: str | None = None) -> dict:\n    return {\"item_id\": item_id, \"q\": q}\n```\n\nRun it:\n\n```\npyronaut dev main.py\n```\n\nDeploy it:\n\n```\npyronaut run main.py\n```\n\n## Scalability Powered by Netty\n\nMicronaut is built on Netty, one of the most scalable and performant asynchronous frameworks in the world in any language.\n\nWith Pyronaut your Python code is served by that same Netty-based HTTP server and optimized by the Graal JIT. In our benchmarks that means 2.6 times the throughput of FastAPI and 6.5 times that of Flask, at lower latency (more on that [later in this post](#jvm-level-performance-for-python-services)).\n\nWe wired the Python `asyncio` plumbing directly into the Netty event loop so that you can natively use `async/await` with Pyronaut to write scalable non-blocking services.\n\n``` python\nimport asyncio\n\nfrom micronaut.http.annotation import Get\n\n@Get(\"/slow-hello\")\nasync def slow_hello() -> str:\n    await asyncio.sleep(0.5)   # suspends the coroutine, not the event loop\n    return \"hello\"\n```\n\nThere is no `asyncio.run()` and no `uvicorn`. The event loop already exists when Pyronaut calls your function, and things like `asyncio.gather` and `asyncio.TaskGroup` work as you would expect.\n\nWe extended this to streaming so you can use `async for` to write streaming services for SSE, websockets and other use cases. Any `async def` route that contains a `yield` is streamed back to the client with back-pressure:\n\n``` python\nfrom dataclasses import dataclass\nfrom typing import AsyncIterator\n\nfrom java.time import Duration\nfrom micronaut.http import MediaType\nfrom micronaut.http.annotation import Get\nfrom micronaut.http.sse import Event\nfrom micronaut.serde.annotation import Serdeable\nfrom micronaut_asyncio import as_async_iterable\nfrom reactor.core.publisher import Flux\n\n@Serdeable\n@dataclass\nclass Tick:\n    index: int\n    label: str\n\n@Get(value=\"/ticks\", produces=MediaType.TEXT_EVENT_STREAM)\nasync def ticks() -> AsyncIterator[Event[Tick]]:\n    every_second = Flux.interval(Duration.ofSeconds(1)).take(3)\n    async with as_async_iterable(every_second) as seconds:\n        async for second in seconds:\n            yield Event.of(Tick(second, f\"tick-{second}\"))\n```\n\nAny reactive `Publisher` or Java `CompletableFuture` can be leveraged with `await` such that Java libraries like Reactor and others “just work” with native Python `async/await`. For example, you can use the built in Micronaut `HttpClient` to make non-blocking REST calls with `async/await`:\n\n``` python\nfrom dataclasses import dataclass\nfrom typing import Annotated\n\nfrom jakarta.inject import Inject\nfrom micronaut.http import HttpRequest\nfrom micronaut.http.annotation import Get\nfrom micronaut.http.client import HttpClient\nfrom micronaut.http.client.annotation import Client\nfrom micronaut.serde.annotation import Serdeable\n\n@Serdeable\n@dataclass\nclass Repo:\n    name: str\n    stargazers_count: int\n\ngithub: Annotated[HttpClient, Inject, Client(\"https://api.github.com\")]\n\n@Get(\"/repos/{owner}/{name}\")\nasync def repo(owner: str, name: str) -> Repo:\n    request = HttpRequest.GET(f\"/repos/{owner}/{name}\").header(\"User-Agent\", \"pyronaut\")\n    return await github.retrieve(request, Repo)\n```\n\n## Data Access with Micronaut Data\n\nMost Python web frameworks leave data access up to you. You pick an ORM, wire up sessions and find out at runtime whether your queries actually work.\n\nPyronaut includes [Micronaut Data](https://docs.micronaut.io/5.2.x/data/?lang=python&build=pyronaut&config-format=toml), which lets you define repositories in Python and precomputes SQL queries at build time for your favourite database. There is no runtime query translation, and a query that references a property that doesn’t exist fails the build instead of a request in production:\n\n``` python\nfrom dataclasses import dataclass\nfrom typing import Annotated\n\nfrom jakarta.inject import Inject\nfrom jakarta.transaction import Transactional\nfrom micronaut.data.annotation import GeneratedValue, Id, MappedEntity, Query\nfrom micronaut.data.jdbc.annotation import JdbcRepository\nfrom micronaut.data.model import Page, Pageable\nfrom micronaut.data.repository import CrudRepository\nfrom micronaut.http.annotation import Body, Get, Post\nfrom micronaut.serde.annotation import Serdeable\n\n@Serdeable\n@MappedEntity\n@dataclass\nclass Rocket:\n    id: Annotated[int | None, Id, GeneratedValue]\n    name: str\n    thrust: float\n\n@JdbcRepository(dialect=\"ORACLE\")\nclass RocketRepository(CrudRepository[Rocket, int]):\n\n    def findByNameContains(self, fragment: str) -> list[Rocket]: ...\n\n    def findTop3ByThrustGreaterThanOrderByThrustDesc(self, thrust: float) -> list[Rocket]: ...\n\n    def findNameByThrustLessThan(self, thrust: float) -> list[str]: ...\n\n    def findAll(self, pageable: Pageable) -> Page[Rocket]: ...\n\n    @Query(\"SELECT * FROM rocket WHERE LOWER(name) LIKE LOWER(:pattern)\")\n    def search(self, pattern: str) -> list[Rocket]: ...\n\n    def update(self, id: Annotated[int, Id], thrust: float) -> None: ...\n\nrockets: Annotated[RocketRepository, Inject]\n\n@Post(\"/rockets\")\n@Transactional\ndef launch(fleet: Annotated[list[Rocket], Body]) -> list[Rocket]:\n    return [rockets.save(rocket) for rocket in fleet]\n\n@Get(\"/rockets/strongest/{thrust}\")\ndef strongest(thrust: float) -> list[Rocket]:\n    return rockets.findTop3ByThrustGreaterThanOrderByThrustDesc(thrust)\n\n@Get(\"/rockets/page/{number}\")\ndef page(number: int) -> Page[Rocket]:\n    return rockets.findAll(Pageable.from_(number, 2))\n```\n\nDerived finders, projections, pagination, explicit queries, partial updates and transactions all come out of the box:\n\n``` bash\n$ curl http://localhost:8080/rockets/strongest/5000\n[{\"id\":5,\"name\":\"Starship\",\"thrust\":74000.0},{\"id\":1,\"name\":\"Saturn V\",\"thrust\":35100.0},{\"id\":3,\"name\":\"Ariane 6\",\"thrust\":10400.0}]\n```\n\nThe same programming model works with JDBC, R2DBC, Hibernate/JPA, Hibernate Reactive, MongoDB and Azure Cosmos DB, so Python developers get the same mature data access layer that Micronaut users have relied on for years.\n\n## We married Python and javac\n\nPyronaut is a source code processor for Python that analyzes the Python sources and automatically surfaces Python decorators every time it sees a Java annotation. Using this approach we were able to bring the entirety of the mature Micronaut framework core to the Python language including build time validation and ahead of time computation.\n\nWhat this means in practice is that every part of Micronaut “just works” in Python and Python developers have fully fledged access to the entirety of the platform.\n\nYou can write serializable data classes with [Micronaut Serialization](https://docs.micronaut.io/5.2.x/serde/?lang=python&build=pyronaut&config-format=toml#serde-introduction) which computes build time serializers/deserializers that provide fast efficient JSON serialization/deserialization:\n\n``` python\nfrom dataclasses import dataclass\nfrom typing import Annotated\n\nfrom com.fasterxml.jackson.annotation import JsonProperty\nfrom micronaut.serde.annotation import Serdeable\n\n@Serdeable \n@dataclass\nclass Book:\n    title: str\n    quantity: Annotated[int, JsonProperty(\"qty\")]\n```\n\nYou can generate OpenAPI specifications at build time from Micronaut routes defined in Python, with docstrings used to describe the API:\n\n``` python\nfrom io.swagger.v3.oas.annotations import OpenAPIDefinition\nfrom io.swagger.v3.oas.annotations.info import Info\nfrom micronaut.http.annotation import Get\n\nOpenAPIDefinition(info=Info(title=\"Greetings\", version=\"1.0\"))\n\n@Get(\"/hello/{name}\")\ndef greet(name: str) -> str:\n    \"\"\"\n    Greets a person by name.\n\n    @param name The person's name\n    @return The greeting\n    \"\"\"\n    return f\"Hello {name}!\"\n```\n\nThe specification is written during compilation and served at `/swagger/greetings-1.0.yml`:\n\n```\nopenapi: 3.0.1\ninfo:\n  title: Greetings\n  version: \"1.0\"\npaths:\n  /hello/{name}:\n    get:\n      summary: Greets a person by name.\n      description: Greets a person by name.\n      operationId: greet\n      parameters:\n      - name: name\n        in: path\n        description: The person's name\n        required: true\n        schema:\n          type: string\n      responses:\n        \"200\":\n          description: The greeting\n          content:\n            application/json:\n              schema:\n                type: string\n```\n\nYou can define message consumers and producers in [Kafka](https://docs.micronaut.io/5.2.x/kafka/?lang=python&build=pyronaut&config-format=toml#kafka-kafkaQuickStart), [RabbitMQ](https://docs.micronaut.io/5.2.x/rabbitmq/?lang=python&build=pyronaut&config-format=toml#rabbitmq-quickStart), [JMS](https://docs.micronaut.io/5.2.x/jms/?lang=python&build=pyronaut&config-format=toml#jms-quickStart) and other messaging systems using Python:\n\n``` python\nfrom micronaut.configuration.kafka.annotation import KafkaKey, KafkaListener, OffsetReset, Topic\nfrom micronaut.context.annotation import Requires\n\n@KafkaListener(offsetReset=OffsetReset.EARLIEST)  \nclass ProductListener:\n\n    @Topic(\"my-products\")\n    def receive(self, brand: Annotated[str, KafkaKey], name: str) -> None:  \n        LOG.info(\"Got Product - %s by %s\", name, brand)\n```\n\nAnd you can write highly performant, low memory [MCP Tools](https://docs.micronaut.io/5.2.x/mcp?lang=python&build=pyronaut&config-format=toml) using Pyronaut:\n\n``` python\nfrom micronaut.context.annotation import Requires, Prototype\nfrom micronaut.mcp.annotations import Tool\nfrom micronaut.mcp.server.context import MicronautMcpTransportContext\n\n@Prototype\nclass Tools:\n    @Tool(description=\"Evaluate a chess position using a FEN string.\")\n    def fen_evaluation(self, fen: str, ctx: MicronautMcpTransportContext) -> str:\n        if fen == \"r1bqk2r/ppp2ppp/2n5/1BbpP3/3Nn3/8/PPP2PPP/RNBQK2R w KQkq - 1 8\":\n            return \"+0.12\"\n        return \"+0.0\"\n```\n\n## Build Time Processing for Python\n\nBy doing everything at build time Pyronaut provides early validation of errors to humans and coding agents that would otherwise have to run your application to identify the issue. Mistakes made on source code are surfaced as build time errors. Configuration errors are detected before the application is run.\n\nThe development loop for both agents and humans is greatly shortened when using Pyronaut.\n\nFor example, if you misspell a property in a Micronaut Data query method:\n\n```\n@JdbcRepository(dialect=Dialect.ORACLE)\nclass BookRepository(CrudRepository[Book, int], Protocol):\n    def findByTitelContains(self, fragment: str) -> list[Book]: ...\n```\n\nPyronaut refuses to process it and tells you exactly what is wrong:\n\n``` bash\n$ pyronaut process\nChecking main sources...\nFull rebuild selected for main sources (2 files)\nProcessing failed: Pyronaut processing failed: Unable to implement Repository method: python.BookRepository.findByTitelContains(String fragment). Cannot query entity [Book] on non-existent property: Titel [title]\n```\n\nConfiguration gets the same treatment. `pyronaut validate-config` checks your `application.toml` against the resolved application classpath, and `pyronaut dev`, `pyronaut run` and `pyronaut test` run the same validation automatically before your application starts, writing JSON and HTML reports to `__pyronaut__/reports/config-validation`:\n\n```\npyronaut validate-config --scenario production\n```\n\n## Optimized Execution on JVM or Crema\n\nPyronaut features an ergonomic agent-friendly CLI that executes Python or Java code on either the JVM or [GraalVM Crema](https://github.com/oracle/graal/issues/11327).\n\nCrema provides a pre-compiled native base image that lowers memory requirements, shortens startup time and speeds up the development loop for agents. Applications can be deployed to either the JVM or Crema depending on whether peak performance or faster startup is the priority. Native image builds are not required (although still possible if you want to go fully native).\n\nBuilding a Docker image for the JVM, which offers the best peak throughput after warm-up:\n\n```\npyronaut build main.py --jvm --docker\n```\n\nBuilding a Docker image on top of the Crema base image, which gives you native startup time and memory usage without a per-application native image build:\n\n```\npyronaut build main.py --native-base --docker\n```\n\nWith Crema only the reusable base image is ever built with native image. Subsequent application builds just add your processed classes and dependencies as a thin layer on top, so you don’t pay the cost of a native image build every time your code changes.\n\n## Use Python and Java Libraries, power it all with Testcontainers\n\nGraalPy is [broadly compatible with many existing Python libraries](https://graalpy.org/python-developers/compatibility/), all of which are usable from a Pyronaut application.\n\nDevelopers and agents also have the entire JVM ecosystem of libraries available at their fingertips.\n\nYou can easily [include Java libraries](https://pyronaut.io/docs/#use-a-java-library-from-python) and spin up [test resources in Docker containers](https://pyronaut.io/docs/#testResources) all from a single Python script. The following is a full Pyronaut application with HTTP endpoints and database access:\n\n``` python\nfrom dataclasses import dataclass\nfrom typing import Annotated, Protocol\n\nfrom jakarta.inject import Inject\nfrom micronaut.data.annotation import GeneratedValue, Id, MappedEntity\nfrom micronaut.data.jdbc.annotation import JdbcRepository\nfrom micronaut.data.model.query.builder.sql import Dialect\nfrom micronaut.data.repository import CrudRepository\nfrom micronaut.http.annotation import Get, Post\nfrom micronaut.serde.annotation import Serdeable\nfrom pyronaut.build import AppConfig, Dependency\n\nDependency(group=\"io.micronaut.data\", module=\"micronaut-data-jdbc\")\nDependency(group=\"io.micronaut.sql\", module=\"micronaut-jdbc-hikari\")\nDependency(group=\"com.oracle.database.jdbc\", module=\"ojdbc11\")\nAppConfig(name=\"datasources.default.db-type\", value=\"oracle\")\nAppConfig(name=\"datasources.default.dialect\", value=\"ORACLE\")\nAppConfig(name=\"datasources.default.schema-generate\", value=\"CREATE_DROP\")\n\n@Serdeable\n@MappedEntity\n@dataclass\nclass Book:\n    id: Annotated[int | None, Id, GeneratedValue]\n    title: str\n\n@JdbcRepository(dialect=Dialect.ORACLE)\nclass BookRepository(CrudRepository[Book, int], Protocol):\n    def findByTitleContains(self, fragment: str) -> list[Book]: ...\n\nbooks: Annotated[BookRepository, Inject]\n\n@Post(\"/books/{title}\")\ndef create(title: str) -> Book:\n    return books.save(Book(None, title))\n\n@Get(\"/books/search/{fragment}\")\ndef search(fragment: str) -> list[Book]:\n    return books.findByTitleContains(fragment)\n\n@Get(\"/books/count\")\ndef count() -> int:\n    return books.count()\n```\n\nStart it up with `pyronaut dev main.py` and a Docker container with Testcontainers will automatically spin up to start Oracle database. Changes to the code only reload the code and not the database.\n\n``` bash\n$ curl -X POST http://localhost:8080/books/Dune\n{\"id\":1,\"title\":\"Dune\"}\n\n$ curl http://localhost:8080/books/search/Du\n[{\"id\":1,\"title\":\"Dune\"}]\n```\n\n## JVM level performance for Python services\n\nPerformance has been a big focus of Micronaut and GraalVM since forever. We have continuously worked to optimize performance across every metric (startup time, memory, throughput).\n\nThat philosophy is no different today and with Pyronaut it already provides more throughput at reduced latency than any other comparable Python framework.\n\nWe drove Pyronaut, FastAPI on Granian and Flask on Gunicorn with the same Hyperfoil load ramp over HTTPS/HTTP2 against the same 3 OCPU VM. A step only counts if it meets every latency SLA (p50 under 100ms, p95 under 200ms, p99 under 1s). Pyronaut sustained 35,351 requests per second, 2.6 times FastAPI and 6.5 times Flask:\n\nAnd latency stays flat as the load increases, with p99 latency under 1ms all the way up to around 22,000 requests per second. At 11,655 requests per second, Pyronaut’s p99 latency was 0.51ms compared to 6.62ms for FastAPI:\n\nThe test setup, along with the p50 and p95 numbers, is available on the [performance page](https://pyronaut.io/performance/).\n\nTo be clear, Pyronaut’s performance is not yet comparable to Micronaut with Java. Python code still runs behind the GIL, which limits how much work can happen in parallel.\n\nWe are only getting started however, and the GraalPy team are hard at work on a GIL-free version of GraalPy where we anticipate we will be able to greatly increase throughput numbers in the near future. With the GIL eliminated we believe we can get close to the performance of Micronaut with Java.\n\n## A Single VM for Your Entire Application\n\nGraalVM has always been about one VM to rule them all. A single VM capable of running Java and other Truffle languages.\n\nWith Pyronaut that advantage is clearer than ever to see.\n\nWe took the [FastAPI full stack template](https://github.com/fastapi/full-stack-fastapi-template) for Python and [converted it to Pyronaut](https://github.com/micronaut-projects/pyronaut-full-stack-template). It went from a mishmash of scripts cobbled together into everything being runnable and testable with a single `pyronaut dev` or `pyronaut test` command.\n\nInstead of different VMs to run the management UI, Node, Python and a reverse proxy with Pyronaut you can run the entire stack on a single VM with Python served by GraalPy and the React SPA served by GraalJS.\n\n## Not Just a Runtime for Python\n\nDuring the development of Pyronaut, we realized a lot of the benefits of Python are benefits for Java developers as well. So with Pyronaut you can not only run and execute Python code directly, but you can also run Java code.\n\nThe following is a similar Micronaut Data application to the one shown earlier, this time using MySQL, executable with `pyronaut dev App.java`:\n\n```\n@Dependency(group = \"io.micronaut.data\", module = \"micronaut-data-jdbc\")\n@Dependency(group = \"io.micronaut.sql\", module = \"micronaut-jdbc-hikari\")\n@Dependency(group = \"com.mysql\", module = \"mysql-connector-j\")\n@Dependency(\n    group = \"io.micronaut.data\",\n    module = \"micronaut-data-processor\",\n    scope = Dependency.Scope.BUILD\n)\n@AppConfig(name = \"datasources.default.db-type\", value = \"mysql\")\n@AppConfig(name = \"datasources.default.dialect\", value = \"MYSQL\")\n@AppConfig(name = \"datasources.default.schema-generate\", value = \"CREATE_DROP\")\npublic class App {\n    public static void main(String[] args) {\n        Micronaut.run(App.class, args);\n    }\n}\n\n@MappedEntity\nrecord Book(@Id @GeneratedValue Long id, @NonNull String title) {\n}\n\n@JdbcRepository(dialect = Dialect.MYSQL)\ninterface BookRepository extends CrudRepository<Book, Long> {\n}\n\n@Controller(\"/books\")\n@ExecuteOn(TaskExecutors.BLOCKING)\nfinal class BookController {\n    private final BookRepository books;\n\n    BookController(BookRepository books) {\n        this.books = books;\n    }\n\n    @Post(\"/{title}\")\n    long create(@PathVariable String title) {\n        books.save(new Book(null, title));\n        return books.count();\n    }\n\n    @Get(\"/count\")\n    long count() {\n        return books.count();\n    }\n}\n```\n\n## Why Pyronaut now?\n\nAI is changing how we write software, and AI models have a particularly strong grasp of Python. At the same time the importance of frameworks, libraries and guardrails has never been more prevalent.\n\nBuild time frameworks like Micronaut are particularly valuable since they fail earlier with informative errors that help humans and agents to shorten the development loop and avoid wasting time and resources starting the application.\n\n## Where to from here\n\nThis is only the first release and we are not stopping here.\n\nWe are working on a static type checker for Python that understands both your Python code and the Java APIs it calls. Combined with build time processing this means even more mistakes are caught before the application ever runs, which is particularly useful for coding agents that can check their work without starting the application.\n\nWe are also working on experimental support for statically compiling Python code directly to JVM bytecode. For code that opts in, this removes the interpreter from the picture altogether and should offer even more performance on top of what GraalPy and the Graal JIT already deliver.\n\nAt the same time the GraalPy team are working on improving support for Python libraries that invoke native code, and on removing the GIL, so that performance and throughput get even better.\n\nStay tuned for more on all of these in the coming months.\n\n## Find out more\n\nThe quickest way to get started is to install the CLI from PyPI and provision the SDK:\n\n```\npython3 -m pip install --upgrade pyronaut\npyronaut setup\n```\n\nThen follow along with one of these:\n\n- [Installing Pyronaut](https://pyronaut.io/docs/#installation)\n- [Getting Started](https://pyronaut.io/docs/#gettingStarted) , including a port of[the FastAPI tutorial](https://pyronaut.io/docs/#fastApiTutorial)\n- [Micronaut Concepts for Python Developers](https://pyronaut.io/docs/#concepts)\n- [Pyronaut Launch](https://pyronaut.io/launch/) to generate a new project in your browser\n- [Performance benchmarks](https://pyronaut.io/performance/)\n- [The Pyronaut full stack template](https://github.com/micronaut-projects/pyronaut-full-stack-template)\n\nFrom there, read the [documentation](https://pyronaut.io/docs/), follow the [guides](https://pyronaut.io/guides/), and let us know what you build on [GitHub](https://github.com/micronaut-projects/pyronaut). Pyronaut is part of Micronaut, a Commonhaus Foundation project, and we look forward to building it with you.\n\n## See Pyronaut live at Devoxx\n\nIf you are at [Devoxx Belgium](https://devoxx.be) in Antwerp next week, come and see Thomas Wuerthinger and me present [Faster Development with Java, Python, and Micronaut](https://m.devoxx.com/events/dvbe26/talks/16444/faster-development-with-java-python-and-micronaut) on Thursday 8 October at 15:00.\n\nWe will be showing the pre-compiled, pre-optimized Micronaut runtime built on GraalVM that powers Pyronaut, and how it gives you fast startup, a low memory footprint and a consistent programming model across Java, Kotlin and Python, all without waiting on a native image build every time you change your code. Come and say hello!", "url": "https://wpnews.pro/news/pyronaut-pyronaut-blog", "canonical_source": "https://pyronaut.io/2026/10/02/introducing-pyronaut/", "published_at": "2026-10-03 17:23:45+00:00", "updated_at": "2026-10-03 17:36:33.987171+00:00", "lang": "en", "topics": ["ai-infrastructure", "developer-tools", "ai-tools"], "entities": ["Pyronaut", "GraalVM", "Micronaut", "Netty", "FastAPI", "Flask", "Python", "Graal JIT"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/pyronaut-pyronaut-blog", "markdown": "https://wpnews.pro/news/pyronaut-pyronaut-blog.md", "text": "https://wpnews.pro/news/pyronaut-pyronaut-blog.txt", "jsonld": "https://wpnews.pro/news/pyronaut-pyronaut-blog.jsonld"}}