https://community.wolfram.com RSS Feed for Wolfram Community showing ideas tagged with Staff Picks sorted by active. https://community.wolfram.com/groups/-/m/t/3717709 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/437e8a0f-3bd5-4330-8049-aa11a9c94850 Marco Thiel 2026-05-18T10:10:15Z https://community.wolfram.com/groups/-/m/t/3717198 ![Time travel through the atmosphere: replaying historical weather from 1940 to today][1] *A 24-hour reanalysis of Hurricane Katrina making landfall on 29 August 2005, reconstructed hour-by-hour from ERA5 alone — no satellite imagery involved. Below: the mechanism behind it, an explanation of why the same trick works for any date since 1 January 1940, and a walk through Apollo 11's launch morning, the 1953 North Sea Flood, the 1987 UK Great Storm, the 2003 European heatwave, Hurricane Katrina, Stephen Wolfram's birthday in 1959, and the winter inside the Stalingrad pocket.* &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=katrina_landfall-resize.gif&userId=20103 [2]: https://www.wolframcloud.com/obj/419d876d-af07-4e6a-98d7-35bd1e67e911 Marco Thiel 2026-05-18T08:46:48Z https://community.wolfram.com/groups/-/m/t/3716885 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/569bbd97-1fa8-456e-b49a-dbdbf68bf7e5 Diego Zviovich 2026-05-15T21:21:37Z https://community.wolfram.com/groups/-/m/t/3716766 [![enter image description here][1]](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/) ## Introduction ["Chatnik"](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/), \[AAp9\], is a Wolfram Language (WL) paclet that provides Command Line Interface (CLI) scripts for conversing with multiple, persistent Large Language Model (LLM) personas. Files of the host Operating System (OS) are used to maintain persistence. Most importantly, "Chatnik" does not try to entrench users in its own user experience (loop) for interaction with LLMs. Instead, it brings customizable LLM invocations and conversations into the Unix shell -- making them composable, integratable, and scriptable with existing workflows. In other words, the tag line "LLM Host in the Shell" should be understood as "LLMs, not as an app -- but as a Unix shell primitive." Here are the most notable "Chatnik" features: - Provides UNIX shell pipelining for LLM interactions - Maintains a database of LLM chat objects - Connects to multiple models across different LLM providers - Offers access to a large repository of prompts - Enables convenient retrieval of interaction history - Includes management tools for the LLM chat object database - Preprocesses prompts using a simple domain-specific language (DSL) - Supports loading user-defined LLM personas from JSON files **Remark:** "Chatnik" closely follows the LLM-chat objects interaction system of the Python package ["JupyterChatbook"](https://pypi.org/project/JupyterChatbook/), \[AAp3\], and Raku package ["Jupyter::Chatbook"](https://raku.land/zef:antononcube/Jupyter::Chatbook), \[AAp7\]. Another (remote) resemblance can be found with the Wolfram Language paclet ["Chatbook"](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/Chatbook/), \[CGp1\]. (In other words, using OS shells instead of Jupyter or Wolfram notebooks.) **Remark:** The WL paclet "Chatnik", \[AAp9\], is a translation of the Raku package ["Chatnik"](https://github.com/antononcube/Raku-Chatnik), \[AAp8\] and the Python package ["Chatnik"](https://pypi.org/project/Chatnik/), \[AAp4\]. The WL CLI scripts are with CamelCase, i.e. `LLMChat`, `LLMChatMeta`, and `LLMPrompt`. The corresponding CLI scripts of the Raku package use kebab-case, i.e. `llm-chat`, `llm-chat-meta`, and `llm-prompt`. The corresponding CLI scripts of the Python package use snake_case, i.e. `llm_chat`, `llm_chat_meta`, and `llm_prompt`. **Remark:** In addition, the Raku package provides the "umbrella" CLI `chatnik`. **Remark:** When the phrase "Chatnik system" is used that is in order to emphasize that there are "Chatnik" packages in several programming languages with (almost) the same design and usage. The rest of this document is organized as follows: - Introductory examples - Why make another LLM-CLI system? - Architectural design - Related and alternative packages ---- ## Introductory examples The examples in this section demonstrate how the CLI scripts `LLMChat` and `LLMChatMeta` -- provided by "Chatnik" -- are used to have multi-turn LLM conversations and compose Unix shell pipelines with LLM interaction messages. **Remark:** In order to use these scripts use the function [`ChatnikCopyScripts`](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/ref/ChatnikCopyScripts.html) after installing "Chatnik". **Remark:** The prompts used in the examples are provided by the [Wolfram Prompt Repository (WPR)](https://resources.wolframcloud.com/PromptRepository/). Many of those prompts are also available in Python and Raku via the packages ["LLMPrompts"](https://pypi.org/project/LLMPrompts), \[AAp2\], and ["LLM::Prompts"](https://raku.land/zef:antononcube/LLM::Prompts), \[AAp6\], respectively. ### Chat with Yoda Here we create an LLM persona -- by naming it and "priming it" with a prompt -- and start interacting with it: ```shell LLMChat 'Hi! Who are you?' --chat-id=yoda --prompt=@Yoda ``` ``` # Yoda, I am. Wise and old Jedi Master, yes. Help you with the Force, I will. Hmm. ``` Here we continue the conversation -- using the `--i` synonym of `--chat-id`: ```shell LLMChat 'How many students did you have?' --i=yoda ``` ``` # Many students, I have trained in my long life. Countless, they are. Luke Skywalker, young Anakin, and others, yes. Teach them the ways of the Force, I did. Hmm. Important balance, training Jedi is. Patience and wisdom, the path to success they are. ``` And continue the discussion some more: ```shell LLMChat 'Which student is the best?' --i=yoda ``` ``` # Best student, difficult to say, it is. Each has strengths and weaknesses, hmmm. Luke Skywalker, strong in the Force he is. Anakin, powerful but troubled, hmmm. Learn from mistakes, all must. Judge by heart and actions, we should. Humble and wise, the true measure of a Jedi is. Yes. ``` The example used the LLM persona ["Yoda"](https://resources.wolframcloud.com/PromptRepository/resources/Yoda). (See more LLM personas [here](https://resources.wolframcloud.com/PromptRepository/category/personas?sortBy=Name).) ### Fortune-echo-limerick pipeline Here we specify a pipeline for 1. Getting a fortune 2. Echoing it 3. Using the fortune to make a limerick ``` fortune | tee /dev/tty | LLMChat --prompt="Make a limerick from the given text:" ``` ```text I have made this letter longer than usual because I lack the time to make it shorter. -- Blaise Pascal There once was a note, quite verbose, Longer than needed, I suppose. Pascal said with a grin, “To be short takes more spin,” So brevity’s craft he chose to oppose. ``` **Remark:** In the shell command above, `LLMChat` created (or reused) a chat object with the default identifier "NONE". ### Make a diagram from previous results Here we use prompt expansion to request the creation of a [Mermaid-JS diagram](https://mermaid.js.org) via the prompt ["CodeWriterX"](https://www.wolframcloud.com/obj/antononcube/DeployedResources/Prompt/CodeWriterX/): ``` LLMChatMeta last-message --i=NONE | LLMChat - --i=mmd --prompt='Make a mermaid.js sequence diagram #NothingElse|"mermaid.js code"' ``` ```` ```mermaid sequenceDiagram participant Blaise as Blaise Pascal participant Note as Note participant Reader as Reader Blaise->>Note: Write verbose letter Note->>Reader: Deliver longer-than-usual message Blaise->>Reader: "To be short takes more spin" Note->>Reader: "Brevity's craft opposed" ``` ```` Since the result is given in Markdown code fences we take the last message via the CLI script `LLMMetaChat`, then use `sed` to remove the first and last lines, and then pass that text to the terminal Mermaid-JS visualizer [`mmdflux`](https://github.com/kevinswiber/mmdflux): ``` LLMChatMeta last-message --i=mmd | sed '1d; $d' | mmdflux ``` ```text ┌───────────────┐ ┌──────┐ ┌────────┐ │ Blaise Pascal │ │ Note │ │ Reader │ └───────┬───────┘ └───┬──┘ └────┬───┘ │ │ │ │─Write verbose letter──────────────>│ │ │ │ │ │ │─Deliver longer-than-usual message─>│ │ │ │ │─"To be short takes more spin"──────────────────────────────────────────>│ │ │ │ │ │─"Brevity's craft opposed"─────────>│ │ │ │ ``` **Remark:** Since the result is usually given in Markdown code fences, we did not make a pipeline to plot the diagram. We used two shell commands in order to observe the intermediate result. **Remark:** The default object identifier for both `LLMChat` and `LLMChatMeta` is "NONE". ### Copy-editing Here is a very practical example -- this document was copy-edited with the prompt ["CopyEdit"](https://resources.wolframcloud.com/PromptRepository/resources/CopyEdit) using the following commands: ``` cat Chatnik-LLM-Host-in-the-Shell-Part-1.md | LLMChat - --i=ce --prompt=@CopyEdit --model=gpt-5.4-mini --max-tokens=16384 LLMChatMeta last-message --i=ce > Chatnik-LLM-Host-in-the-Shell-Part-1_edited.md open Chatnik-LLM-Host-in-the-Shell-Part-1_edited.md ``` (And, yes, the LLM copy-edited version was evaluated, and some edits were rejected.) --- ## Why make another LLM-CLI system? ### Some questions to answer * Why do it? * Why was it relatively easy to do? * Why is it useful? ### Why do it? Most LLM interfaces -- both "big" popular ones and those built by developers experimenting with LLMs -- default to an application-centric design: a closed interaction loop with implicit state. This pattern is convenient, but very limiting. It can be cynically seen as an intentional effort for user lock-in or just as an attempt to impose certain user-experience views. It works against the "freedom enabling" Unix design principles. (Such as composability, transparency, and scriptability.) With "Chatnik", instead of adapting workflows to fit an LLM application, LLM capabilities are brought into the shell as first-class primitives. This enables reuse of existing tooling (pipes, redirects, scripts) and aligns LLM interaction with long-established UNIX practices. ### Why was it relatively easy to do? "Chatnik" is a composition of existing capabilities rather than a ground-up implementation: * Modern LLM providers (e.g., OpenAI, Google, Ollama) expose messy, non-uniform APIs that should be abstracted behind a single interface * The Raku ecosystem already provides flexible text processing, DSL making and usage, and CLI tooling * The "LLM::Functions" package encapsulates model interaction patterns, reducing knowledge of concrete APIs * Persistence can be implemented with simple file-based storage, avoiding the need for complex infrastructure **Remark:** Related to the last point above, the following quote is attributed to [Ken Thompson](https://en.wikiquote.org/wiki/Ken_Thompson) about UNIX: > We have persistent objects, they're called files. **Remark:** Less obnoxiously, instead of saying that LLM providers expose messy, non-uniform APIs, we can say that their APIs "are individually reasonable, but collectively inconsistent." Because of the popularity of OpenAI's models, many LLM providers adhere to a degree with OpenAI's API. Still, the APIs -- collectively -- have inconsistent schemas, authorization, streaming, tool-calling, roles, etc. ### Why is it useful? "Chatnik" is useful because it places LLM capabilities in a natural manner into Unix shell workflows: * LLM calls can be embedded into shell pipelines, enabling automation and chaining * Conversations are persistent and inspectable via the file system * Prompt reuse and DSL preprocessing reduce repetition and keep workflows clear * Multiple providers can be used interchangeably without changing workflows * Existing UNIX tools (e.g., `grep`, `awk`, `sed`) can be combined with LLM outputs * Also, additional "widgets", like Markdown viewers, Mermaid-JS renderers, etc. ---- ## Architectural design The following flowchart summarizes the computational components and their interactions fairly well: [![enter image description here][2]](https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/refs/heads/master/MarkdownDocuments/Diagrams/Chatnik-LLM-Host-in-the-Shell-Part-1/Chatnik-WL-flowchart-LR-light.png) Here is a concise narration of the flow: - A chat command is issued from the OS shell, triggering ingestion of the chat objects file into an in-memory chat database. - If a chat ID is specified and exists, the corresponding chat object is retrieved; otherwise, a new chat object is created (with a default “NONE” ID if unspecified). - The input is then processed through prompt parsing using a DSL. If known prompts are detected, they are expanded via the prompt repository; otherwise, the raw input proceeds directly. - The resulting message is evaluated through "LLM::Functions", which mediates interaction with external providers such as OpenAI (ChatGPT), Google (Gemini), and Ollama. - The evaluation produces a chat result returned to the shell, while the updated chat state is written back to the chat objects file, ensuring persistence. ### Expanded narration **Chatnik is built around the principle that LLM interaction should behave like a native shell capability, not a siloed application.** A command issued in the OS shell is treated as the entry point into a composable pipeline, where LLM calls can participate alongside standard UNIX tools. **State is externalized and file-backed, not hidden in process memory.** Chat sessions are represented as chat objects that are ingested from and persisted to the file system. This makes conversations durable, inspectable, and naturally versionable using existing OS tools. **Chat identity is explicit but optional.** When a chat ID is provided, the corresponding conversation is resumed; when absent or unknown, a new chat object is created. This allows both ad-hoc interactions and long-lived conversational contexts without friction. **Prompting is treated as a programmable layer.** Inputs are not passed directly to models; they are first parsed through a lightweight DSL. Known prompts are expanded from a prompt repository, enabling reuse, parameterization, and standardization of interactions. **LLM invocation is abstracted but not obscured.** Evaluation is delegated to "LLM::Functions", which provides a uniform interface over multiple providers, including OpenAI (ChatGPT), Google (Gemini), and Ollama. This keeps provider choice flexible while preserving a consistent workflow. **The system is designed for composability and integration.** Each stage—state ingestion, prompt processing, evaluation, and persistence—can be understood as part of a pipeline. This makes LLM interactions scriptable, chainable, and interoperable with existing command-line utilities. **Persistence is a first-class outcome of every interaction.** Every evaluation both returns a result to the shell and updates the underlying chat object store, ensuring that conversational context evolves incrementally and reliably. **In short.** To reiterate the point in the introduction, "Chatnik" treats LLMs as *shell-native, stateful, and programmable primitives* -- aligning conversational AI with the philosophy of UNIX pipelines rather than application-bound interfaces. ----- ## Related functions and packages In this section, we point to Raku packages that are both ingredients of, and alternatives to, "Chatnik". ### Main ingredients The LLM-chat object functionalities (creation and interaction) are provided by the Wolfram Language functions [`LLMConfiguration`](https://reference.wolfram.com/language/ref/LLMConfiguration.html), \[WRIf1\], [`LLMPrompt`](https://raku.land/zef:antononcube/LLM::Functions), \[WRIf2\], and [`LLMSynthesize`](https://reference.wolfram.com/language/ref/LLMSynthesize.html), \[WRIf3\]. In addition, the expansion of the [prompt DSL](https://writings.stephenwolfram.com/2023/06/introducing-chat-notebooks-integrating-llms-into-the-notebook-paradigm/#applying-functions-in-a-chat-notebook), \[SW1\], is done by the function [`ChatnikPromptExpand`](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/ref/ChatnikPromptExpand.html). The CLI script `LLMPrompt` of "Chatnik" can be used to examine, retrieve, and concretize prompts. For example, here it can be seen the full text of the function prompt "MermaidDiagram" with given arguments: ``` LLMPrompt MermaidDiagram MYTEXT MY_DIAGRAM_TYPE ``` In some cases it is more convenient to use `LLMPrompt` than prompt expansion. For example: ``` LLMChat "FOCUS TEXT START :: $(cat README.md) :: FOCUS TEXT END" | LLMChat - --i=fb --prompt="$(LLMPrompt ThinkingHatsFeedback 'FOCUS TEXT')" ``` Here is the context (prompt) of the chat object "fb": ``` LLMChatMeta context --i=fb ``` We can see the outcome of the `LLMChat` pipeline above with: ``` LLMChatMeta last-message --i=fb | cat > chat.md ``` ### Parsing of CLI arguments The paclet ["CommandLineParser"](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/CommandLineParser/), [MSp1], is used to parse the CLI arguments of the "Chatnik" scripts. The parser has certain limitations: - The non-named CLI arguments must be placed before the named ones. - The named arguments allways start with `--`. (I.e. `-i` does not work, `--i` does.) Because [`$ScriptInputString` is not very reliable](https://mathematica.stackexchange.com/q/204021) the positional argument `-` can be used to specify that the pipeline value as the input to `LLMChat`. ### Including `wolframscript` Of course, we can utilize "full power" of `wolframscript` (or WL) by making pipelines that combine LLM generations with WL computations. For example, here we get LLM-retrieved statistics and plot them (using the last message of the chat with "beta" above): ``` LLMChatMeta last-message --i=beta | sed '1d; $d' | wolframscript -code 'gr=ImportString[Import["!cat", "String"],"RawJSON"]//ReverseSort//ListPlot[#, ImageSize->600, PlotTheme -> "Detailed", PlotRange->All]&; Export["./beta.png", gr]' && open ./beta.png ``` <img src="https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/refs/heads/master/MarkdownDocuments/Diagrams/Chatnik-LLM-Host-in-the-Shell-Part-1/beta.png" width="400" height="248" alt="Example Image"> ---- ## References ### Articles, blog posts \[AA1\] Anton Antonov, ["Jupyter::Chatbook"](https://rakuforprediction.wordpress.com/2023/09/03/jupyterchatbook), (2023), [RakuForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA2\] Anton Antonov, ["Jupyter::Chatbook Cheatsheet"](https://rakuforprediction.wordpress.com/2026/03/14/jupyterchatbook-cheatsheet), (2026), [RakuForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA3\] Anton Antonov, ["Jupyter Chatbook Cheatsheet"](https://pythonforprediction.wordpress.com/2026/03/12/jupyter-chatbook-cheatsheet), (2026), [PythonForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA4\] Anton Antonov, ["Chatnik: LLM Host in the Shell — Part 1: First Examples & Design Principles"](https://rakuforprediction.wordpress.com/2026/04/25/chatnik-llm-host-in-the-shell-part-1-first-examples-design-principles/), (2026), [RakuForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA5\] Anton Antonov, ["Chatnik: LLM Host in the Shell — Part 1: First Examples & Design Principles"](https://pythonforprediction.wordpress.com/2026/05/04/chatnik-llm-host-in-the-shell-part-1-first-examples-design-principles/), (2026), [PythonForPrediction at WordPress](https://pythonforprediction.wordpress.com). \[SW1\] Stephen Wolfram, ["Introducing Chat Notebooks: Integrating LLMs into the Notebook Paradigm"](https://writings.stephenwolfram.com/2023/06/introducing-chat-notebooks-integrating-llms-into-the-notebook-paradigm), (2023), [Stephen Wolfram Writings](https://writings.stephenwolfram.com). ### Functions \[WRIf1\] Wolfram Research, Inc., [LLMConfiguration](https://reference.wolfram.com/language/ref/LLMConfiguration.html), (2023), [Wolfram Language function](https://reference.wolfram.com/language/), (updated 2025). \[WRIf2\] Wolfram Research, Inc., [LLMPrompt](https://reference.wolfram.com/language/ref/LLMPrompt.html), (2023), [Wolfram Language function](https://reference.wolfram.com/language/). \[WRIf3\] Wolfram Research, Inc., [LLMSynthesize](https://reference.wolfram.com/language/ref/LLMSynthesize.html), (2023), [Wolfram Language function](https://reference.wolfram.com/language/), (updated 2025). ### Packages #### Python \[AAp1\] Anton Antonov, [LLMFunctionObjects, Python package](https://github.com/antononcube/Python-packages/tree/main/LLMFunctionObjects), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). ([PyPI.org page](https://pypi.org/project/LLMFunctionObjects).) \[AAp2\] Anton Antonov, [LLMPrompts, Python package](https://github.com/antononcube/Python-packages/tree/main/LLMPrompts), (2023-2025), [GitHub/antononcube](https://github.com/antononcube). ([PyPI.org page](https://pypi.org/project/LLMPrompts).) \[AAp3\] Anton Antonov, [JupyterChatbook, Python package](https://github.com/antononcube/Python-JupyterChatbook), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). ([PyPI.org page](https://pypi.org/project/JupyterChatbook).) \[AAp4\] Anton Antonov, [Chatnik, Python package](https://github.com/antononcube/Python-Chatnik), (2026), [GitHub/antononcube](https://github.com/antononcube). #### Raku \[AAp5\] Anton Antonov, [LLM::Functions, Raku package](https://github.com/antononcube/Raku-LLM-Functions), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). \[AAp6\] Anton Antonov, [LLM::Prompts, Raku package](https://github.com/antononcube/Raku-LLM-Prompts), (2023-2025), [GitHub/antononcube](https://github.com/antononcube). \[AAp7\] Anton Antonov, [Jupyter::Chatbook, Raku package](https://github.com/antononcube/Raku-Jupyter-Chatbook), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). \[AAp8\] Anton Antonov, [Chatnik, Raku package](https://github.com/antononcube/Raku-Chatnik), (2026), [GitHub/antononcube](https://github.com/antononcube). #### Wolfram Language \[AAp9\] Anton Antonov, [Chatnik, Wolfram Language paclet](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/), (2026), [Wolfram Language Paclet Repository](https://resources.wolframcloud.com/PacletRepository). \[MSp1\] Matteo Salvarezza, [CommandLineParser, Wolfram Language paclet](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/CommandLineParser/), (2024), [Wolfram Language Paclet Repository](https://resources.wolframcloud.com/PacletRepository). \[CGp1\] Connor Gray, et al., [Chatbook, Wolfram Language paclet](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/Chatbook), (2023-2024), [Wolfram Language Paclet Repository](https://resources.wolframcloud.com/PacletRepository). ### Videos \[AAv1\] Anton Antonov, ["Integrating Large Language Models with Raku"](https://youtu.be/-OxKqRrQvh0?si=5LEj8-Dtcxjn-0QR&t=548), (2023), [The Raku Conference 2023 at YouTube](https://www.youtube.com/@therakuconference6823). [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Chatnik-Androids-shelf-11-conveyor-clean-lab-WL-styled-small.png&userId=143837 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Chatnik-WL-flowchart-LR-light.png&userId=143837 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=beta.png&userId=143837 Anton Antonov 2026-05-16T09:57:01Z https://community.wolfram.com/groups/-/m/t/3714827 ![Google Earth Engine (GEE) client paclet][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=10966GoogleEarthEngine%28GEE%29clientpaclet.jpg&userId=20103 [2]: https://www.wolframcloud.com/obj/2a2947bc-b39e-494c-9309-173af5069ad5 Diego Zviovich 2026-05-12T01:32:46Z https://community.wolfram.com/groups/-/m/t/3715139 ![Borwein Integrals: UnitBox spectral depletion and the mechanism of integral deviation][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=BorweinIntegrals.png&userId=20103 [2]: https://www.wolframcloud.com/obj/a3cd6afe-f457-4384-a25a-f8a696d214c3 Justin Pearson 2026-05-12T20:11:52Z https://community.wolfram.com/groups/-/m/t/3716833 ![More is less in unpercolated active solids][2] &[Wolfram Notebook][3] [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=S1Final1-optimize2.gif&userId=20103 [3]: https://www.wolframcloud.com/obj/c48dbefc-cd2e-4f75-bcc6-638074499d82 Jack Binysh 2026-05-15T19:39:17Z https://community.wolfram.com/groups/-/m/t/3716486 ![Analytical insights into the transient climate response][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=output.gif&userId=20103 [2]: https://www.wolframcloud.com/obj/2d4a507d-219e-4759-93e3-c1e78ac507da Boriana Chtirkova 2026-05-15T18:44:04Z https://community.wolfram.com/groups/-/m/t/3716438 ![Painting a Kerr black hole: a backward null-geodesic ray tracer with a real astrophotograph][1] *"Hook image: a viewport screenshot from inside an interactive Wolfram viewer, looking at a 360-degree black-hole panorama generated by OpenAI's gpt-image-2. This is AI art -- striking, but not derived from general relativity. The rest of the notebook builds the same scene from physics, in pure Wolfram Language. See Section 11 for the viewer itself."* &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=PaintingaKerrblackhole.jpg&userId=20103 [2]: https://www.wolframcloud.com/obj/1cc09d34-423c-4144-9e2c-c256740295ad Marco Thiel 2026-05-15T09:49:06Z https://community.wolfram.com/groups/-/m/t/3716185 ![Aliens? Or weather balloons? You decide!][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=AliensOrWeatherBalloonsYouDecide.jpg&userId=20103 [2]: https://www.wolframcloud.com/obj/a9f85d83-9d1a-47dc-92bc-bf3cfa1232c4 Arnoud Buzing 2026-05-15T00:20:07Z https://community.wolfram.com/groups/-/m/t/3713047 ![Red hair tips electric eel in fast and slow motion: translating from P5.JS processing to Wolfram][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ezgif-20001a6ec98fb594.gif&userId=11733 [2]: https://www.wolframcloud.com/obj/78388bcc-f070-44d3-9035-26433cf1ce85 Vitaliy Kaurov 2026-05-08T02:51:54Z https://community.wolfram.com/groups/-/m/t/3716240 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/9686986d-0efe-456e-91b3-cc3a5f314495 Housam Binous 2026-05-14T15:25:50Z https://community.wolfram.com/groups/-/m/t/3716255 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/8cb6693a-dd97-4ab3-b753-6f0bbc77d18c Arnoud Buzing 2026-05-14T16:59:43Z https://community.wolfram.com/groups/-/m/t/3710334 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=diracmatrix-hero-wolfram-warm-v2.png&userId=1539902 [2]: https://www.wolframcloud.com/obj/c44dcf0b-91ae-4386-933e-d1f5219fdd86 Mohammad Bahrami 2026-05-01T22:54:55Z https://community.wolfram.com/groups/-/m/t/3715214 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/f3cc5b88-f290-4e68-ac29-2d450c373fd1 Diego Zviovich 2026-05-12T23:08:24Z https://community.wolfram.com/groups/-/m/t/3706475 ![Getting Started with Modelica][1] I'm excited to share that my new book, **Getting Started with Modelica**, is now available on Amazon. >[**Amazon Page**][2] **Who is it for?** Engineers and students taking their first serious steps with Modelica. No prior Modelica experience required. If you are already using System Modeler for drag-and-drop modeling and want to understand what is happening under the hood, or start writing your own textual models, this book is for you. **What does it cover?** The essentials you need to go from zero to writing and reading Modelica code. Acausal modeling and connectors, the Modelica Standard Library, inheritance, events, arrays, functions, records, solver internals, and FMI. By the end, you will be able to read code from the Modelica Standard Library, write your own models, and diagnose common problems independently. **Why does it matter in the age of LLMs?** LLMs can generate Modelica. But spotting when it's wrong takes a human who understands the language. This book builds that understanding. # Selected Figures from the Book ## 1. Why Modelica? — multi-domain systems ![enter image description here][3] *Multi-domain system: battery, fluid/thermal, and control logic coupled in a single model.* Real systems rarely live in one physical domain. An EV battery's state-of-charge depends on its temperature, which depends on the coolant loop, which depends on the control logic that watches both. Modelica lets you describe each domain in its own language — electrical, thermal, fluid, control — and assemble them in one simulation, with the coupling at the boundaries handled by the connectors. ## 2. Causal vs. acausal modeling ![enter image description here][4] *Causal approach requires two separate models; one acausal Modelica model handles both naturally.* This is the single image that captures what makes Modelica different. A signal-based tool freezes the direction of information flow at design time, so a motor and a generator are two different models even though the physics is identical. In Modelica you write the equations once; the compiler decides at solve time whether torque is the input or the output, based on how the component is connected. The same DC machine model handles motoring and regeneration — no manual switching, no duplication. ## 3. Hybrid simulation: continuous + discrete ![enter image description here][5] *Thermostat simulation: continuous temperature dynamics and discrete switching in one run.* Real engineering systems mix smooth continuous physics with sharp discrete events: a valve opens, a relay clicks, a controller switches mode. Modelica handles both natively — the solver pauses cleanly at each event, applies any state changes, and resumes. Here the water heats up continuously while a discrete control signal toggles the heater on and off around the setpoint, all inside the same simulation. ## 4. The bouncing ball — events done right ![enter image description here][6] *Bouncing ball height: each arc lower than the last as energy is lost to the restitution coefficient.* The bouncing ball is the canonical event-handling test in any simulation language. The solver follows ballistic flight, detects each ground impact as a zero-crossing, reinitializes the velocity through Modelica's `reinit()` operator, and continues. The energy loss per bounce is captured in a single coefficient of restitution — no special-case code, no workarounds. ## 5. Why event handling matters ![enter image description here][7] *Modelica stops at discontinuities and handles them explicitly; signal-based tools approximate them as steep smooth curves.* A common workaround in signal-based tools is to model a switch as a steep sigmoid. It looks tidy, but the steep gradient forces the integrator into tiny time steps and can cause solver failures at extreme parameter values. Modelica represents the discontinuity honestly — the solver stops, re-initializes, and continues — which is both faster and numerically robust. ## 6. Inheritance in the Modelica Standard Library ![enter image description here][8] *MSL Resistor inheritance chain: each level adds exactly one thing (connector, voltage difference, current conservation, Ohm's law).* The Modelica Standard Library is built on disciplined object-oriented design. The Resistor doesn't define its pins, voltage difference, or current bookkeeping — those are inherited from three abstract layers above it (`Pin`, `TwoPin`, `OnePort`). The concrete component contributes one equation: `v = R*i`. This is why MSL components compose so cleanly across thousands of models and dozens of domains. ## 7. A real engineering example — heated pipe ![enter image description here][9] *The pipe system: fluid enters at T_in, loses heat through wall resistance R_wall to ambient T_ambient.* Chapter 10 builds a heated-pipe model from scratch over four stages, introducing one new concept at each step — geometry parameters, fluid properties, the energy balance, then heat loss to the environment. This sketch is the physical picture the model is built from. The pedagogy: start from a drawing of the physics, name the variables, then write the equations. ## 8. Simulation result of the heated pipe ![enter image description here][10] *PipeSystem over 20 s: Re constant at ~12,700, Q_loss decreasing as T_fluid decays exponentially toward steady state.* The matching result plot for the model above. Three quantities tell a coherent story: Reynolds number stays in the turbulent regime throughout, the wall heat flux falls as the fluid cools, and the fluid temperature decays smoothly toward the ambient-influenced steady state. A clean separation of timescales — and exactly the kind of multi-variable readout System Modeler's Simulation Center produces by default. ## 9. Data integration — wind turbine ![enter image description here][11] *Full data chain: a CombiTimeTable feeds wind speed to both an efficiency lookup and a power block; their outputs multiply to give actual power.* Engineers often ask: "what do I do when I don't have equations?" Many real components — heat pumps, compressors, rotor blades — are characterized by manufacturer curves or measurement data, not closed-form physics. Modelica's `CombiTable` family lets you connect tabular data directly into the same diagram as your equation-based components, and the solver treats them consistently with everything else. Here, time-series wind speed flows into an efficiency curve and a cubic-power model, and the product is the turbine's actual output. ## 10. Inside the compiler — the symbolic preprocessing pipeline ![enter image description here][12] *The symbolic preprocessing pipeline: from hierarchical model to block triangular form, runs automatically at every compile.* When a Modelica tool compiles a model it isn't just translating code — it's performing a sequence of symbolic transformations: flattening the hierarchy, simplifying, reducing differentiation index, selecting state variables, building a bipartite dependency graph, finding a maximum matching, breaking strongly connected components, and emitting block-triangular code the numerical solver can step through. The user never sees this; the user just sees a model that runs. ## 11. The bipartite graph behind every Modelica model ![enter image description here][13] *Maximum matching assigns each equation to the one variable it solves; the thick edges define the computation direction.* This is the moment a Modelica model becomes solvable. Equations and variables form a bipartite graph; an edge means "this variable appears in this equation." A maximum matching pairs each equation with the unique variable it will be used to compute — turning an undirected web of relations into a directed computation order. The same picture, shown as an incidence matrix on the right, is how a sparse linear-algebra package would see it. (The kind of structure a Wolfram Language audience tends to enjoy.) ## 12. FMI — Modelica's tool-interoperability story ![enter image description here][14] *FMI as a universal connector: an FMU exported from any tool can be imported by any other FMI-compliant tool.* Once a model is built, the Functional Mock-up Interface (FMI) lets it cross tool boundaries. A Wolfram System Modeler component can be exported as an FMU, dropped into a Simulink controller study, embedded in a Python automation script, or run on dSPACE real-time hardware-in-the-loop. The simulation asset outlives any single tool — a real concern for long-lived models in aerospace, automotive, and energy. ## 13. The Modelica landscape — what the book covers ![enter image description here][15] *What this book covered vs. what lies beyond: a map of where you stand and where the path continues.* A reader's-eye view of the book's scope. On the left, the topics the book takes the reader through to fluency: equation-based modelling, the standard library, custom components, events and state machines, records, arrays, inheritance, replaceable components, data integration, FMU export, the solver pipeline, and functions. On the right, the topics that lie beyond — stream connectors, homotopy initialisation, multi-phase flow, real-time/HIL — pointing the reader to where to go next. ## 14. Application gallery — a building chiller ![enter image description here][16] *Chiller model from the Buildings library: condenser and evaporator loops connected through the chiller, with control inputs and fluid boundary conditions.* Modelica's reach into building energy simulation is substantial. The Buildings library (developed at LBNL) provides hundreds of validated HVAC components — chillers, heat pumps, fans, control sequences — that compose into whole-building models suitable for design and operational studies. This figure shows a single chiller with its condenser and evaporator loops; full plant models scale to thousands of components. ## 15. Application gallery — a DC motor drive ![enter image description here][17] *DC motor drive model: a voltage source drives current through the EMF, which converts electrical energy to rotational motion against a load.* The DC motor is the textbook example of an acausal multi-domain model — and it's also a real component that ships in countless products. One diagram crosses two physical domains: the electrical loop (resistor, inductor, EMF) and the rotational mechanical loop (inertia, damper, speed sensor). The energy conversion at the EMF couples the two automatically through the connector equations. Set the input voltage profile and the speed comes out; reverse the boundary conditions and the same model behaves as a generator. [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=cover_kindle.png&userId=20103 [2]: https://www.amazon.com/Getting-Started-Modelica-Language-Modeling-ebook/dp/B0GY94LXQS [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch01_multi_domain_system.png&userId=20103 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch01_causal_vs_acausal_motor.png&userId=20103 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch01_hybrid_model_thermostat_plot.png&userId=20103 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch07_bouncing_ball_height_plot.png&userId=20103 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch07_event_vs_smooth_approximation.png&userId=20103 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch08_msl_resistor_inheritance_hierarchy.png&userId=20103 [9]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch10_heated_pipe_physical_diagram.png&userId=20103 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch10_pipesystem_simulation_result.png&userId=20103 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch11_wind_turbine_data_chain_diagram.png&userId=20103 [12]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch12_symbolic_preprocessing_pipeline.png&userId=20103 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch12_bipartite_graph_maximum_matching.png&userId=20103 [14]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch14_fmi_universal_connector_diagram.png&userId=20103 [15]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch16_modelica_coverage_map.png&userId=20103 [16]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch16_gallery_buildings_chiller.png&userId=20103 [17]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ch16_gallery_dc_motor_drive.png&userId=20103 Ankit Naik 2026-04-27T09:42:54Z https://community.wolfram.com/groups/-/m/t/3715438 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/2dd621c0-ea9a-45aa-88da-6e4db8750a21 Jana Rusrus 2026-05-13T02:52:25Z https://community.wolfram.com/groups/-/m/t/3715016 ![Hat tile dynamics from dual-grid projection onto a fractal-subdivided torus][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=titleImage.png&userId=2932486 [2]: https://www.wolframcloud.com/obj/644687a3-8e85-4505-b3bc-cc74fbc04ee9 Johannes Martin 2026-05-12T09:53:01Z https://community.wolfram.com/groups/-/m/t/3714716 ![A computational survey of the Theta invariant][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=5999AcomputationalsurveyoftheThetainvariant.png&userId=20103 [2]: https://www.wolframcloud.com/obj/ac7f8f6b-bc74-4bc2-ac75-e68fa28f1260 Ali Karim Lalani 2026-05-11T19:20:13Z https://community.wolfram.com/groups/-/m/t/3713462 ![Superoscillations Part I: 1D foundations, leaky functions and quantum wavefunctions][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Image20260511195639.png&userId=20103 [2]: https://www.wolframcloud.com/obj/8d53f8f8-2805-49dd-b7bc-ee20599a9be9 Bruno Tenorio 2026-05-08T22:22:16Z