Welcome back to another edition of our monthly Positron updates! Each month we share highlights from our latest release and useful resources. Last release we told you about several major features that came out of preview to general availability, including the new notebook editor. This milestone we are excited to share new functionality for SQL support, reproducible authoring, helping you know when packages are missing, and more.

Data Connections

Data Connections is our new way to work with SQL and database-like resources in Positron, from local files and database servers to cloud data warehouses. It is currently available as a preview feature, and you can enable it with the dataConnections.enabled setting. This release more than doubles the number of data sources you can reach. Amazon Redshift, Snowflake, Databricks, and Posit Connect pins join the existing DuckDB, PostgreSQL, and SQLite support.

The panel itself is more capable as well. Refresh and Refresh All reload the tree while preserving what you have expanded, briefly highlighting the rows that were reloaded. Open connections now show an indicator. Collapsing a connection in the UI keeps you connected to your data source, while anything you’ve previewed with the Data Explorer stays still open. When you remove a connection, Positron asks for confirmation and reports how many Data Explorers will close with it.

Data Connections is still an experimental preview, and your feedback continues to shape it. Tell us which databases and warehouses you need, and anything confusing, missing, or broken, in the Data Connections discussion.

Inline output for Quarto

Inline output for .qmd documents came out of preview last release, and this release brings you a substantial round of polish for this way of working. Be aware that the Quarto settings have moved into a dedicated quarto.* namespace with its own group in the Settings editor. The previous positron.quarto.* keys still work but are deprecated, and Positron will prompt you to update your settings.

Before a kernel starts, the kernel status names the interpreter it will start and offers an explicit Start Kernel action. When a cell fails, Fix and Explain buttons send the error to Posit Assistant, matching the Positron notebook experience. The editor also scrolls to reveal output as it is produced, which you can turn off with the new quarto.inlineOutput.autoScroll setting.

Output renders more faithfully as well. The editor gutter now shows which statement is currently executing and per-statement progress. Positron draws images at your display’s pixel ratio, so plots are sharp on retina screens, and Python figures now respect the fig-width and fig-height cell options.

HTML widgets no longer stick in the editor corner when you scroll past them, or trap scrolling instead of letting the document scroll. HTML widgets no longer render as raw HTML after a reload, and collapsed output no longer springs back open when its cell re-runs. Running code in a Quarto document also pins the editor tab now, so Positron does not silently close the document and its session when you open another file.

AI model providers

Positron now reads AI model provider configuration from a single providers.json file rather than a scattered set of settings. The new release will migrate your existing configuration automatically when you start it, and deprecates the authentication.* and positron.assistant.provider.*.enable settings in favor of it. Two new commands give you direct access: Open AI Provider Settings (JSON) opens providers.json from the Command Palette, and Migrate Provider Settings to providers.json runs the migration on demand.

Install missing packages

Positron now notices when your code refers to a package you do not have installed and offers to install it for you. The prompt appears for packages referenced by your scripts and notebooks in both R and Python.

A library() or import call for something missing becomes a single click instead of an error you have to go resolve by hand.

Performance and memory

We continue to invest in the memory footprint, performance, and reliability of Positron. Several components now load only when they are actually needed, and turning off ai.enabled now means Positron never loads some heavy AI-related components at all. We fixed a cluster of long-standing reliability problems around session restarts and lifecycles.

Startup and editing are faster as well. R and Python kernels start much faster on Windows systems with aggressive antivirus software. The interpreter session picker appears immediately instead of waiting for interpreter discovery to finish. We also fixed slow typing, formatting, and saving in long R and Python files.

What’s coming next

• Join our upcoming webinar on August 26 to learn about AI governance in Posit Workbench.
• We are looking forward to posit::conf(2026) next month, where our team will have several sessions on Positron. Register now to join us in person in Houston or virtually from anywhere in the world.

Welcome to our newsletter, posit::glimpse()!

If you’re currently reading this on our blog, consider subscribing to Product Updates - Open Source on our subscription page to receive this newsletter directly in your inbox.

Every month, we round up some of the most important open-source news for Posit’s community! We hope that you enjoy this newsletter and maybe even share it with a friend.

The table of contents on the right can help you navigate through all the updates. As you scroll, it will open up to show you subcategories →

Announcements

Register for posit::conf(2026)

Register for our annual conference, posit::conf(2026), happening September 14-16 in Houston and online! The amazing speakers and workshops will make for a wonderful time. Register for posit::conf here.

For the first time, the live streams will feature automatically translated subtitles, available in French, German, Italian, Portuguese, and Spanish.

Tidy Dev Day is on September 17, a unique opportunity to collaboratively tackle open-source issues and work directly alongside the very developers who build and maintain the tools you use every day. Learn more about Tidy Dev Day here.

Migrating to Connect Cloud

A thank-you to everyone who published on rpubs.com, quartopub.com, shinyapps.io, and bookdown.org. We’re consolidating all our publishing tools into one: Posit Connect Cloud. Connect Cloud is built to handle all of the content types in one place, with one account, and we hope to make your transition as smooth as possible.

• Learn more in the Migrating to Connect Cloud: Posit’s unified publishing solution blog post.
• Join our webinar on the migration process happening September 9th.

Key product updates and new releases

httr2 1.3.0

httr2 is a comprehensive HTTP client for R for working with web APIs. httr2 1.3.0 introduces a breaking change to OAuth token caching that requires one-time re-authentication. Recent patches added 200x faster streaming for short-line responses, OAuth server metadata discovery, OpenTelemetry tracing support, and httr2_translate() for converting requests to curl commands.

• Read more in the httr2 1.3.0 blog post.

ir 0.1.0

Introducing ir 0.1.0, a command-line tool for running self-describing R scripts and Quarto documents with embedded package dependencies and R version requirements, inspired by Python’s PEP 723 and uv run --script. The tool supports isolated environments, CRAN snapshot dates, mixed R/Python workflows, and caches resolved dependencies for efficiency, enabling one-file workflows without full project structures.

• Read more in the ir 0.1.0 blog post.

lorax

lorax introduces a unified interface for characterizing tree- and rule-based models across 12 implementations including ranger, XGBoost, LightGBM, and random forests. The package enables extracting decision rules, identifying active predictors, converting trees to partykit format for visualization, and accessing variable importance scores through consistent APIs that work across diverse tree model packages.

• Read more in the Introducing lorax: Speaking for the Tree-Based Models blog post.

mcptools 1.0.0

mcptools, an R SDK for the Model Context Protocol, is now on CRAN. It brings image support for rich content in both directions, native authenticated remote server connections eliminating the npm dependency, and streamlined Posit Connect deployment via _server.yml. This R SDK for the Model Context Protocol enables deploying R functions as MCP servers and fetching third-party MCP tools as R functions.

• Read more in the mcptools 1.0.0 blog post.

Quarto 1.10

Quarto transforms Markdown, code, and computational output into publication-ready articles, reports, presentations, websites, and books. Version 1.10 introduces offline HTML accessibility checking with bundled axe-core and WCAG conformance level targeting, plus localized string support for template authors. The release includes important fixes for quarto preview reliability, shortcode resolution in math expressions, and updated dependencies including pandoc 3.10 and typst 0.15.1.

• Read more in the Quarto 1.10 blog post.

raghilda v0.2

Raghilda is a Python package for building RAG (Retrieval-Augmented Generation) solutions. This release focuses on production-ready features for scaling RAG pipelines, with crawl and ingest API with caching and concurrency, a CloudflareCrawler for JavaScript-rendered sites, a PostgreSQL store backend, and NVIDIA NIM embeddings.

• Check out the raghilda v0.2 blog post.

roxygen2 8.1.0

roxygen2 8.1.0 improves performance with consolidated importFrom() directives that reduce package loading time from ~120ms to ~9ms for 1,000 imports, and introduces the rdtools package for faster cross-reference resolution during documentation generation. The release also adds multi-line support for @importFrom directives with hanging indents.

• Check out the roxygen2 8.1.0 blog post.

Shiny updates

Shiny is the framework for building interactive web applications in R and Python. Shiny for R 1.14 adds startApp() for non-blocking app launches and session$destroy() for proper module cleanup. Shiny for Python 1.7 includes bundled Agent Skills for coding agents and test mode with live JSON snapshots. bslib 0.12 introduces offcanvas panels that slide in from viewport edges, plus direct sidebar handle resizing.

• Read more in the Shiny updates blog post.

Positron learning resources

The Positron team is on a roll. Here are the key features from the July Release Highlights:

• The Positron Notebook Editor now serves as the default option for .ipynb files: You get a fully integrated experience for Jupyter Notebooks out of the box. Key tools like environment management, version control, and AI coding support work automatically the moment you open any .ipynb file.
• The Packages pane has officially transitioned out of preview status: Inspect, update, and explore installed libraries without leaving your IDE or relying on Terminal commands.
• Posit Assistant has reached general availability: AI assistance is enterprise-ready: enjoy full-fledged coding assistance, debugging help, and inline explanations directly in your workflow with improved stability and performance.
• Support for opening Excel workbooks has been added to Data Explorer: No need to export to CSV or switch to Microsoft Excel to check your data: preview, filter, inspect .xlsx sheets directly inside Positron before running any code.
• Enhanced language intelligence for R: Navigating large R projects is much faster and less error-prone with features like Go to Definition, Find References, and Rename Symbol that work across all packages and scripts in your workspace. Diagnostics update instantly even when files change externally.

The team has also shared several blog posts packed with tips and tricks for getting the most out of Positron:

• Discover how Positron paired with uv configures your Python environment in just one click
• Explore strategies for seamlessly managing your R and Python environments within Positron

Let’s learn about AI

You can now receive the AI newsletter via email! Paste the newsletter’s RSS feed URL into a free RSS-to-email service like https://blogtrottr.com/ to receive the newsletter by email.

• AGENTS.md, Skills, MCP servers, oh my! If you’ve heard all these terms and want to investigate the differences, check out the July 3rd edition of the AI Newsletter.
• LLMs often miss subtle visual artifacts in data visualizations, and there are ways of evaluating their oversights. Learn about bluffbench in the July 17th edition of the AI Newsletter.
• Posit Assistant in Positron now includes an EDA log feature to help you keep track of exploratory analysis done with the agent. Learn more in the July 31st edition of the AI newsletter.

Do you want event recordings? You got them!

“Will this be recorded?” If it is, you can access our recordings directly on the event pages, and we do our best to post them as quickly as possible.

Be sure to catch the presentations featured below, including Teun van den Brand’s session on ggsql and Rich Iannone’s presentation on Great Docs:

Jun 30, 2026 | 12 min | 2.1k views

DuckCon #7 – ggsql: A grammar of graphics for SQL (Teun van den Brand)

Event: DuckCon #7 (DuckDB and DuckLake community conference), https://duckdb.org/events/2026/06/24/duckcon7/ Speaker: Teun van den Brand (Posit PBC) Slides: https://blobs.duckdb.org/events/duckcon7/teun-van-den-brand-ggsql.pdf

Teun Van den Brand

ggsql

Jul 6, 2026 | 1h 5min | 114 views

Great Docs: The Future of Documentation | The Python Exchange June 2026

About the Python Exchange for the Department of Energy: https://meetup.doepy.org/ Sign up here to be notified when the next Python Exchange is scheduled: https://bit.ly/py-exchange Guest Panelist: Rich Iannone Title: Great Docs: Building the Documentation Site Generator I Always Wanted Bio: Rich Iannone Rich is a software engineer and someone who cares a great deal about documentation and summary tables. He’s been working on table presentation and documentation packages for quite a long time, and nobody has told him to stop yet, so he’s still on top of all that. He started off mostly creating open-source packages in R, but more lately, he’s been doing open-source things in Python. Rich really enjoys creating all these packages because he realizes that people can use ’em to do great things in their own work. Abstract: Documentation generators have, for me, been a thing where there are so many trade-offs. They might make beautiful sites, but be shallow feature-wise. Or full of features but really hard to configure. After some years of working across R, Python, and the broader open-source ecosystem, I started Great Docs with a simple end goal: your docs should look really great, be easy to discover, and be ready for the AI era. In this presentation, I will walk through the various places I drew inspiration for Great Docs (pkgdown, MATLAB, Elixir, and the Vue.js docs). I’ll show how Great Docs makes documentation consumable by both humans and AI agents through Skills and MCP server documentation. I’ll share some of the features I obsessively built because I wanted them in my own package docs. Finally, I’ll discuss where this project is headed beyond Python (toward documenting CLIs, TUIs, and more). At Don’t Use This Code, we want to create a unique opportunity to see Python succeed and thrive within the DOE. In collaboration with an organizing committee of Python users and advocates from various DOE sites, we host regular conversations on the topic of Python in order to create a new resource for scientists, researchers, and technical staff. Our goal is to share best practices and build a strong, lasting community for Python users within the Department of Energy National Lab system. If you, or someone you know, might make a great panelist, we’d love to get in touch! Just send us an email at DOEPy@dutc.io if you would like to participate or have any questions

Rich Iannone

Great Docs pkgdown

Additionally, we have some fantastic recordings from the Data Science Lab. Watch the Lab Managers share their expertise while live coding:

Jul 24, 2026 | 51 min | 48 views

Live TidyTuesday Data Viz Workflow | Nicola Rennie | Data Science Lab

The Data Science Lab is a live weekly call. Register at pos.it/dslab! Discord invites go out each week on lives calls. We’d love to have you! The Lab is an open, messy space for learning and asking questions. Think of it like pair coding with a friend or two. Learn something new, and share what you know to help others grow. On this call, Libby Heeren is joined by Nicola Rennie, who walks through her process for making a TidyTuesday data visualization in R: live coding a chart from scratch and sharing the workflow tricks she’s built up over five years of doing TidyTuesday! Nicola takes this week’s TidyTuesday “twin cities” dataset and builds a colorful sunburst (radial) chart from scratch, showing how she decides what to plot, wrangles the data with dplyr, and makes it pretty using showtext fonts, rcartocolor palettes, colored-text legends, and the ggview package for previewing plots at exactly the size they’ll save at. Along the way she shares the templates and helper packages she’s made to save time every week (can you tell she’s a pro?!). Since TidyTuesday data is public, you can grab the same dataset and follow along, too! Hosting crew from Posit: Libby Heeren, Isabella Velasquez Socials and websites: Nicola Rennie’s blog: https://nrennie.rbind.io/ Nicola Rennie’s GitHub: https://github.com/nrennie Nicola Rennie’s Bluesky: https://bsky.app/profile/nrennie.bsky.social Nicola Rennie’s LinkedIn: https://www.linkedin.com/in/nicola-rennie/ Nicola Rennie’s Mastodon: https://fosstodon.org/deck/@nrennie Resources mentioned in the video and chat: Nicola’s code from this session: https://nrennie.rbind.io/talks/posit-ds-lab/ TidyTuesday on GitHub: https://github.com/rfordatascience/tidytuesday Nicola’s templates package: https://github.com/nrennie/templates showtext package (fonts in R): https://github.com/yixuan/showtext ggview package (preview plots at save size): https://github.com/idmn/ggview rcartocolor package (accessible color palettes): https://nowosad.r-universe.dev/rcartocolor ggtext package (styled/colored text): https://wilkelab.org/ggtext/ ggiraph package (interactive ggplots): https://davidgohel.github.io/ggiraph/ marquee package (markdown text in R graphics): https://marquee.r-lib.org/ Nicola’s book, The Art of Data Visualization with ggplot2: https://nrennie.rbind.io/art-of-viz/ Bootstrap Icons: https://icons.getbootstrap.com/ okpalette (extract a palette from a photo): https://okpalette.color.pizza/ ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh The Lab: https://pos.it/dslab LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Timestamps 00:00 Introduction 01:18 Reviewing the TidyTuesday twin cities dataset 03:41 Demoing TidyTuesday template files and R package setup 07:25 “Do showtext and systemfonts do different things?” 09:04 Loading and prepping the links and cities datasets 11:45 Exploring and filtering the dataset to a chosen city 17:25 Demoing a Shiny app to copy previous TidyTuesday chart code 23:56 Demoing sunburst chart creation with coord_radial 25:47 “Can you say why you used mutate rather than summarize?” 31:09 Adding custom colors with the rcartocolor package 33:57 Demoing colored subtitle text with the ggtext package 40:38 Attempting to make the chart interactive with the ggiraph package 43:32 Adding automated social and source captions 46:26 “So you can save a plot with the canvas call and it doesn’t mess up the ggplot object?” 49:55 “If people would like to keep up with you and see your posts, what’s the best way to do that?”

dplyr ggplot2 Shiny systemfonts

Jul 23, 2026 | 56 min | 1.1k views

Mind-Blowing Quarto Slide Extensions 💬 🖍️ 🤯 | Emil Hvitfeldt | Data Science Lab

The Data Science Lab is a live weekly call. Register at pos.it/dslab! Discord invites go out each week on lives calls. We’d love to have you! The Lab is an open, messy space for learning and asking questions. Think of it like pair coding with a friend or two. Learn something new, and share what you know to help others grow. On this call, Libby Heeren is joined by Emil Hvitfeldt, who walks through the art of “slide crafting” in Quarto and shows off the collection of Reveal JS extensions he’s been building to make slides way more fun and powerful. Emil starts with the basics of building slides in Quarto with the Reveal JS format (fragments, columns, a little CSS) and explains how Quarto extensions differ from packages. Then he shows off the good stuff: iMessage-style chat bubbles hand-drawn “rough notation” highlighting and annotations ️ the Flourish extension for animating code chunks, gorgeous reusable themes, and his in-progress “editable” extension that lets you drag, resize, and restyle slide elements right in the browser and save the changes back to your source. And, spoiler, his “editable” extension is much further along as of the publishing of this video!! If you’ve ever fought with slide layouts, there is definitely something here you can try at home! Hosting crew from Posit: Libby Heeren, Isabella Velasquez Emil’s socials and urls: website: https://emilhvitfeldt.com/ GitHub: https://github.com/emilhvitfeldt Bluesky: https://bsky.app/profile/emilhvitfeldt.bsky.social LinkedIn: https://www.linkedin.com/in/emilhvitfeldt/ Resources mentioned in the video and chat: Emil’s GitHub (home of his Quarto extensions): https://github.com/EmilHvitfeldt quarto-revealjs-editable extension: https://github.com/EmilHvitfeldt/quarto-revealjs-editable quarto-revealjs-rows extension (shared by Emil after the session): https://github.com/EmilHvitfeldt/quarto-revealjs-rows Quarto Reveal JS documentation: https://quarto.org/docs/presentations/revealjs/ Quarto Reveal JS demo slides: https://quarto.org/docs/presentations/revealjs/demo/#/title-slide News! Quarto 2 (Quarto in Rust): https://quarto.org/docs/blog/posts/2026-04-06-whats-next-quarto-2/ Dynamic Tabsets in Quarto (Josh Cowley): https://josh.quarto.pub/posts/2022-11-10-quarto-tabsets-update/2022-11-10-quarto-tabsets-update.html Embedding Reveal JS via iframe (Quarto source example): https://github.com/quarto-dev/quarto-web/blob/main/docs/presentations/revealjs/index.qmd#L12-L14 posit::conf 2026: https://conf.posit.co/2026/ R/Medicine conference: https://rconsortium.github.io/RMedicine_website/ Muntasir Masum’s slides repo: https://github.com/muntasirmasum/epi553-data-viz Example Quarto slides — Nicola Rennie (Styling Charts): https://nrennie.rbind.io/MFC-CDT-data-viz/slides/styling-charts-r.html Example Quarto slides — Colin Madland: https://cmadland.github.io/slides/ Colin Madland’s slides repo: https://github.com/cmadland/slides Example Quarto slides — Raha Dastgheyb (R/Medicine 2024): https://rdastgh1.quarto.pub/rmedicine-2024-scidatareportr/#/title-slide ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh The Lab: https://pos.it/dslab LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Timestamps 00:00 Introduction 01:22 Demoing a primer on Reveal JS slides in Quarto 05:11 “Does that PDF export still use Pandoc, or is there an option of exporting via Typst?” 08:17 Demoing slide crafting with a new Quarto document 11:24 Demoing how to download and use a Quarto template 14:01 “Is this UI you’re using for slide generation exclusive to Positron?” 16:16 Demoing how to install a Quarto extension from the terminal 18:45 “Is there a maximum number of columns you can have?” 19:18 Demoing adding custom CSS classes to slide columns 23:03 “Do we know if extensions will still be submitted to the OpenVSX marketplace?” 25:11 “Are these Quarto extensions global, or are they per project?” 27:42 “When you change the text fonts inside those columns, could you do it for all the columns at once, maybe by changing the top div?” 29:31 “Do you also get grid logic like you have with CSS Grid?” 31:54 Demoing Quarto VS Code extensions for autocomplete and shortcodes 34:32 Demoing the chat bubbles extension 37:38 Demoing the rough notation extension for highlighting text fragments 40:20 Demoing the Flourish extension for highlighting code chunks 43:07 Demoing the editable extension for dragging and adjusting slide elements 49:28 Demoing custom Reveal JS slide themes 52:26 “Is there a Quarto extension that can help dynamically create tabs or chunks?” (see dynamic tabs link in the resources above!) 53:58 Explaining the default code chunk highlighting feature in Quarto 55:11 “How do you embed a Reveal JS site into another Quarto document?”

Emil Hvitfeldt

Positron Quarto revealjs

We hope you learn a lot from these resources!

Showcases from the community

We love learning what you are up to. If you have a project using our tools to share, please let us know. In particular, I’d love to hear how you’re adopting and using Positron! Find me on LinkedIn and Bluesky.

Alfredo H. S. shared a small, opinionated skill for turning papers and other source material into concise Quarto RevealJS presentations with AI coding agents.

Try it out, and let Alfredo know how it goes!

• Forum discussion
• About the skill
• SKILL.md

REYL Intesa Sanpaolo’s Risk Management team built their own Incident Management Tool with Shiny and Posit Connect, cutting incident follow-up from days to 30 minutes. Now, they’re eyeing the same R-and-Connect pattern for liquidity monitoring, credit risk appetite, and stress testing.

• Check out the spotlight

Interested in testing your regression skills? Angela Heberger is looking for feedback on RelationLab, an interactive Shiny app for learning correlation and regression. Give it a shot and let Angela know what you think!

• Forum discussion
• Shiny app

We usually find these projects on social media. If you’re on LinkedIn, be sure to follow and tag Posit Open Source for us to share the amazing things you’re working on!

What’s next

Besides posit::conf (have you registered for conf yet? You should!), we have lots of goodies on the horizon.

• Emil Hvidtfelt is leading a 2-hour workshop all about making great slides in Quarto on Aug 12th. Register here!
• Join us for an upcoming Data Science Hangout or Data Science Lab.

I would love to know how to make the Glimpse newsletter better. Email me at isabella [dot] velasquez [at] posit.co.

install.packages(c("shiny", "bslib"))

pip install -U shiny

The highlights: bundled agent skills that teach coding agents how to write Shiny for Python apps, startApp() for running R apps without blocking your console, offcanvas panels that slide in from the edge of the viewport, and destroy() for cleaning up dynamic modules.

Full details are in the Shiny for R release notes, the bslib release notes, and the Shiny for Python changelog.

Agent skills

Shiny for Python only — coming to R soon.

Coding agents are writing more and more Shiny apps — so we’re teaching them how to do it well. Shiny for Python v1.7 ships with bundled Agent Skills: a shiny-for-python skill whose SKILL.md routes agents to focused reference files covering each area of Shiny’s public API — reactivity, Express mode, modules, layouts, plots, data frames, chat and streaming, extended tasks, testing, debugging, OpenTelemetry, and more.

To install the bundled skills into your coding agent, use library-skills:

uvx library-skills --claude

Because the skills ship inside the package, they always match the version of Shiny you have installed — and shiny skills list shows what’s bundled.

Now your agent stops hand-rolling HTML tables and fake tabs, and starts using the framework the way you would.

Non-blocking apps

Shiny for R only.

runApp() blocks your R console until the app stops. New in Shiny v1.14, startApp() runs the app in the background and hands control right back to you:

# Start app in the background
handle <- startApp("myapp")

# The console remains available
handle$status()
#> [1] "running"
handle$url()
#> [1] "http://127.0.0.1:7365"

# Stop the app
handle$stop()

The returned ShinyAppHandle has stop(), status(), url(), and result() methods. Starting a new app automatically stops the previous one, so iterating is as simple as calling startApp() again.

This is handy for interactive development, but it really shines for anything that needs to drive an app and keep working: testing tools, coding agents, or scripts that launch an app, interact with it, and shut it down.

That’s the tooling around your app. The next two features are about the app itself — starting with a new way to keep UI off screen until someone asks for it.

Offcanvas panels

An offcanvas is a panel that slides in from an edge of the viewport — perfect for settings, filters, details-on-demand, or anything else that doesn’t need to be on screen all the time. It’s built on Bootstrap 5’s offcanvas component and comes with the full set of server verbs: show_offcanvas(), hide_offcanvas(), and toggle_offcanvas().

The simplest way to use one is with a trigger element — no server code required:

library(shiny)
library(bslib)

ui <- page_fluid(
  offcanvas(
    "Panel content goes here.",
    title = "Settings",
    trigger = actionButton("open", "Open settings")
  )
)

from shiny.express import ui

ui.offcanvas(
    "Panel content goes here.",
    title="Settings",
    trigger=ui.input_action_button("open", "Open settings"),
)

Give the panel an id and it becomes fully programmable: control it from the server and reactively respond to whether it’s open.

library(shiny)
library(bslib)

ui <- page_fluid(
  actionButton("toggle", "Toggle details"),
  offcanvas("Panel content", title = "Details", id = "details")
)

server <- function(input, output, session) {
  observeEvent(input$toggle, toggle_offcanvas("details"))

  observeEvent(input$details, {
    message("Panel is open: ", input$details)
  })
}

shinyApp(ui, server)

from shiny import reactive
from shiny.express import input, render, ui

ui.input_action_button("toggle", "Toggle details")

ui.offcanvas("Panel content", title="Details", id="details")


@reactive.effect
@reactive.event(input.toggle)
def _():
    ui.toggle_offcanvas("details")


@render.text
def state():
    return f"Panel is {'open' if input.details() else 'closed'}"

Panels can slide in from the left, right, top, or bottom, and you can even build one entirely in the server and reveal it with show_offcanvas() — no UI placement needed.

Offcanvas panels are available now in Shiny for Python v1.7 and in bslib v0.12 for R. See the offcanvas() (R, Python) reference for the panel itself, and show_offcanvas(), hide_offcanvas(), and toggle_offcanvas() (R, Python) for controlling it from the server.

Module cleanup

An offcanvas hides UI that’s already there. Creating and destroying UI on the fly is a different problem, and modules make it easy to add UI and server logic dynamically. Removing them has always been the awkward part: removeUI() takes the HTML away, but the module’s observers, reactive values, and outputs keep running behind the scenes — leaving behind “dangling reactivity”.

The session’s new destroy() method (R, Python) closes that gap. The parent that inserted a module can now clean it up by the same id it used to insert it — no cleanup handles to pass around:

# In the parent server
observeEvent(input$add, {
  insertUI("#container", ui = myModuleUI("editor"))
  myModuleServer("editor")
})

observeEvent(input$remove, {
  removeUI(selector = "#editor")
  session$destroy("editor")
})

@reactive.effect
@reactive.event(input.add)
def _():
    ui.insert_ui(my_module_ui("editor"), selector="#container")
    my_module_server("editor")


@reactive.effect
@reactive.event(input.remove)
async def _():
    ui.remove_ui(selector="#editor")
    await session.destroy("editor")

Destroying a scope invokes all of its registered onDestroy() (R) / on_destroy() (Python) callbacks, cleaning up reactive values, expressions, observers, inputs, and outputs for that module and its descendant modules. Everything is scoped, so the parent session and sibling modules are untouched. And a module can call destroy() on its own session (no id) to clean up after itself.

If your app inserts and removes modules over a long-lived session, destroy() keeps those removed modules from accumulating as memory and reactivity leaks.

Test mode

Shiny for Python only.

Back to agents for a moment. The bundled skills teach them how to write your app; test mode, also new in v1.7, lets them — and your tests — see inside it while it runs. Enable it with the SHINY_TESTMODE=1 environment variable (or App(test_mode=True)), and each session serves a live JSON snapshot of its input, output, and exported values.

The snapshot is only served when test mode is enabled, and by default it includes only inputs and outputs. To surface an internal reactive — a reactive.calc or reactive.value that never reaches the UI — export it with export_test_values():

from shiny import reactive, render
from shiny.express import input, ui
from shiny.testmode import export_test_values

ui.input_slider("n", "N", min=0, max=100, value=20)


@reactive.calc
def doubled() -> int:
    return input.n() * 2


@render.text
def txt() -> str:
    return f"n * 2 = {doubled()}"


# Surface the internal reactive in the test-mode snapshot. This is a no-op
# unless test mode is enabled, so it's safe to leave in production code.
export_test_values(doubled=doubled)

The pytest app fixtures (local_app, create_app_fixture) enable test mode automatically, and the new shiny.playwright.controller.AppTestValues controller reads the snapshot in end-to-end tests. Expectations accept exact values or predicates:

def is_even(value):
    return value % 2 == 0

app_values = controller.AppTestValues(page)
app_values.expect_export("doubled", 40)
app_values.expect_export("doubled", is_even)

Test mode mirrors R’s long-standing exportTestValues() — and it gives coding agents a structured way to debug a running app directly from the server instead of inferring information from the UI.

New to testing Shiny apps? Start with Unit testing and End-to-end testing on the Shiny for Python website, then browse the testing API reference.

Other improvements

A few more changes worth a quick mention — the full lists are in the release notes for Shiny for R v1.14.0, bslib v0.12.0, and Shiny for Python v1.7.0:

R

• downloadButton() and downloadLink() gain an enabled argument. The default, "auto", automatically enables the button once the download is ready.
• Output resize and visibility detection now uses native browser observers (ResizeObserver, IntersectionObserver), so plot sizing and hidden-state tracking work in any layout — including CSS-only show/hide and non-Bootstrap frameworks.
• conditionalPanel() no longer briefly flashes its contents on app start when the condition is initially FALSE.
• bslib v0.12 also lets you grab the sidebar handle directly to resize a sidebar, and fixes the resize handle indicator for position = "right" sidebars.

Python

• @render.download_button and @render.download_link pair 1:1 with ui.download_button() and ui.download_link(), replacing the now-deprecated @render.download.
• The shiny[otel] extra now sets up OpenTelemetry zero-code auto-instrumentation out of the box: opentelemetry-instrument shiny run app.py.

In closing

We’re excited to see what you build (and clean up) with these releases. As always, if you have questions or feedback, join us on Discord or open an issue on rstudio/shiny or posit-dev/py-shiny. Happy Shiny-ing!

Acknowledgements

A big thank you to all the folks who helped make these releases happen:

Shiny for R v1.14.0

@adit-0132, @ahnungslos-git, @byronvickers, @cpsievert, @cuckooland, @djacob65, @dmurdoch, @elnelson575, @FBrockmeyer, @gadenbuie, @HenrikBengtsson, @IvanM26, @jcheng5, @jeffkeller-einc, @jeis4wpi, @JohnCoene, @JosiahParry, @karangattu, @klin333, @lachlansimpson, @lionel-, @marcosnav, @mconflitti-pbc, @ml-ebs-ext, @nbenn, @Noskario, @prinjos, @pyltime, @rikivillalba, @roberson4627-cpu, @samuelbharti, @schloerke, @shikokuchuo, @simon-smart88, @toph-allen, and @Upipa.

bslib v0.12.0

@AleKoure, @ArthurAndrews, @averissimo, @elnelson575, @etiennebacher, @gadenbuie, @jeis4wpi, @LeonidasZhak, @lgaborini, @lgschuck, @sawelch-NIVA, @sims1253, and @willgearty.

Shiny for Python v1.7.0

@chernojagne, @cpsievert, @eeshsaxena, @elnelson575, @EltonChang1, @FBruzzesi, @gadenbuie, @hutch3232, @JosiahParry, @karangattu, @kb071216, @kbzsl, @marcosnav, @mariameraz, @MukundaKatta, @mvanhorn, @nightcityblade, @pevolution-ahmed, @QuintonBaker-USDA, @saisharan0103, @SamEdwardes, @schloerke, @slupczynskim, @Steven314, and @tomaioo.

Quarto 1.10 is dominated by fixes, as much of our development effort is now going into Quarto 2, but there are some improvements we wanted to point out: more refined HTML accessibility checks, and access to Quarto’s localized strings for template authors.

You can read about these improvements and the most important fixes below. You can find all the changes in this version in the Release Notes.

Accessibility Checking Improvements

Since Quarto 1.8, setting the axe option on HTML documents runs axe-core accessibility checks on your rendered document. Quarto 1.10 makes these checks easier to rely on.

Checking works offline. Quarto now bundles its own copy of axe-core instead of loading it from a CDN in the reader’s browser. Accessibility checking works without a network connection, and viewing a rendered document no longer triggers a request to an external CDN. The axe-core version is unchanged, so results are identical.

Check against a WCAG conformance level. The new standard option scopes checks to a WCAG conformance level, including rules axe-core keeps off by default for that level. The best-practice option controls whether axe’s best-practice rules, recommendations not required by any WCAG success criterion, are also checked:

format:
  html:
    axe:
      standard: wcag21aa
      best-practice: true

A clearer report. When using output: document, violations are now listed first by impact, then WCAG conformance level. The report overlay also received its own accessibility and styling fixes: it can be scrolled with the keyboard, uses theme and brand independent colors, and no longer inherits page styling like text centering.

Learn more at HTML Accessibility.

Localized Strings in Templates

If you write custom Pandoc templates or template partials, you can now use Quarto’s localized strings through the new quarto.language template variable namespace. Quarto resolves each string for the document’s language and exposes it as a template variable:

$quarto.language.toc-title-document$
$quarto.language.crossref-fig-title$

This lets templates honor the document’s lang option without hard-coding text. For example, the orange-book Typst book extension now uses these variables in its running headers, so a book with lang: fr gets Chapitre rather than Chapter.

Learn more at Localized Strings in Templates.

Other Important Fixes

• quarto preview reliability—a long-standing bug that showed stale HTML for non-index pages is fixed, changes to a document’s format: are detected on the first render after the edit, a _brand.yml added or removed during preview is picked up, and transient .quarto_ipynb files no longer accumulate on disk.

• Shortcodes—shortcodes are now resolved inside inline and display math expressions.

• PDF font fallbacks—mainfontfallback, sansfontfallback, and monofontfallback no longer crash LuaLaTeX on TeX Live 2026, and a missing fallback font is now installed automatically.

• Typst fonts—fonts not installed locally are filtered from CSS font-family fallback lists before they reach Typst, suppressing unknown font family warnings, alongside a batch of fixes to Quarto’s CSS-to-Typst translation.

• Chrome Headless Shell—the quarto install chromium command, deprecated in 1.9, now transparently redirects to chrome-headless-shell, quarto check install warns about legacy Chromium installs, and arm64 Linux is now supported.

• Output for LLMs—fixes for websites with llms-txt enabled: headings and shortcodes inside conditional content, and clean-URL rewriting of index.html.md links.

Dependency updates:

• pandoc updated to 3.10
• typst updated to 0.15.1
• deno updated to 2.7.14
• dart-sass updated to 1.101.0
• esbuild updated to 0.28.1

Acknowledgements

We’d like to say a huge thank you to everyone who contributed to this release by opening issues and pull requests:

AlexLietard, ArthurRudolph, Artmann, C-Monaghan, ChrisJefferson, CoryMcCartan, DCEW, DrFloLinke, Guest-1013, MBe-iUS, MurzNN, ThierryO, ThomasFaria, TinasheMTapera, Voorhoeve, alderete, andrewheiss, barendgehrels, basm92, blauzo, chainsawriot, crisbour, cs-res-pub-ser-st, dustinstoltz, eculler, eneveu, github-actions[bot], gregswinehart, hwine, ianpittwood, ihrke, jdonaldson, jiangyun-fun, jidanni, jkrumbiegel, jnkatz, jph00, jtkulas, juleswg23, juliohm, kazuyanagimoto, kelli-rstudio, lsbjordao, luismmontilla, maelle, maucejo, memeplex, micedre, multimeric, nathant181, neilernst, nessan, nickvigilante, nrennie, pbosetti, reckoner, rgouveiamendes, robjhyndman, sbwiecko, seandavi, sebastiansauer, skyfroger, songwupei, stefkuypers, stragu, tiagojct, victorrssx, widlarizer, wlatendresse, xuefeng-xu, yasyf, zinc75.

The hammer and wrench emoji in the listing and social card image for this post comes from OpenMoji– the open-source emoji and icon project. License: CC BY-SA 4.0

Data scientists are often forced to choose between the simplicity of the classic Jupyter notebook experience and the advanced capabilities of a general-purpose IDE. With the 2026.07 release, you no longer have to choose: Positron now delivers a first-class Notebook Editor inside an IDE built for data science.

If you’re new to Positron, here’s what the Notebook Editor is like in your daily work.

Environment management

You clone your colleague’s repo and try to rerun their notebook. Which Python version do you use? What dependencies do you install and which versions? Did you previously set up an environment that you could reuse? You’re faced with all of these questions before you’ve run a single line of code.

Positron has several built-in workflows to help you manage your environments. When you open a repo, Positron discovers your installed environments, suggests the right one for the repo, and prompts you to set up a new environment if needed. The active environment is displayed front and center; click to restart or switch environments. Positron uses the same environment across your Jupyter and Quarto notebooks, scripts, and consoles. You can see inside your environments, which packages are installed, their versions, whether newer versions are available, and you can upgrade them. Environments are first-class citizens of Positron. Explore Positron’s environment management.

Interactive data exploration

When you run a cell in your notebook, your variables appear in the Variables Pane. Filter, sort, and search your data in the Data Explorer, and try out plot variations in the Visualize wizard. You can easily convert your point-and-click interactions into code by using the copy-code feature to bring them back into your notebook. If you get stuck, look up library documentation in the Help Pane. All of this works out of the box.

Streamlined version control

Notebooks store outputs and execution metadata alongside code, which is great for sharing but does not work well with version control. Positron includes settings to exclude outputs and execution metadata from the saved file, so the diff is just your code change. Explore the custom settings to clean up your git diffs.

Your notebooks stay ordinary .ipynb files and the editing experience stays classic Jupyter. When a plain-text workflow suits you better, conversion to and from .ipynb and other formats is built in.

AI assistance

Posit Assistant sees your notebook as more than just text. It works with the live session behind the notebook: your variables, your data, your plots. Ask it to fix a chart and it can inspect the dataframe, look at the plot itself, edit the cell, and run it again. It does the same things you would do, using the same panes you use. Explore notebook-aware AI assistance in Positron.

Get started

Download Positron and open a project with a Jupyter notebook. The Notebook Editor is now on by default. If you’re coming from another IDE, your existing .ipynb files will open as-is without any conversion needed.

For the full feature reference, check out our documentation.

If you run into any issues or have ideas on how we can improve Positron, reach out on GitHub.

Already using Positron? Everything in this release is in the release notes.

Thank you so much for helping us build Positron’s Jupyter notebook support from the ground up by chatting with us live, sharing your pain points, and giving us feedback on GitHub!

Today we are announcing the first public release of ir, a small command-line tool that runs R scripts and renders Quarto documents using runtime requirements declared in the file itself.

ir is for one-file workflows that do not quite need a project but still need to be easy to share and rerun later. Simply put the package requirements, and optionally the R version, next to the code. When you render or execute the file, ir resolves the requirements, prepares cached package libraries, and launches R or Quarto with a runtime ready to use.

The interface is inspired by PEP 723 and uv run --script. A script can carry enough metadata to describe its runtime, and the runner can resolve that runtime into a cached environment on demand. ir brings that pattern to R scripts and Quarto documents, using pak, renv, and rig on the R side, and reticulate’s uv-backed helper when Python is part of the runtime.

ir focuses on two workflows:

• running or rendering self-describing scripts and documents
  (ir run, ir render)
• running or installing command-line tools distributed through R packages
  (rx, ir tool install)

Why ir?

R scripts often begin as small, local utilities: a report, a data pull, a model-training or evaluation run, a quick diagnostic, or an example shared with a colleague. Over time, the script can become important, but the setup still lives somewhere else: in a README, in a shell history, in a project library, or in the author’s current R installation.

ir makes the runtime specification part of the source file. That means a script can say, directly:

• which packages it needs
• which R should run it, when that needs to be explicit
• whether user libraries should be visible
• whether CRAN packages should be resolved as of a specific date

This should help you rerun the script reliably at a later date. Keeping the metadata in the file makes it less likely to be lost or fall out of sync with the code.

How ir fits with existing tools

ir sits alongside the R tools people already use and builds on several of them directly:

• rig installs, removes, and switches between R versions on macOS, Windows, and Linux. ir calls rig when a file requests a specific R version, or when date-only exclude-newer needs to select the latest R minor version available on that date. rig is optional for files that only declare packages.
• pak is a fast package installer with a built-in solver. ir uses pak to resolve the dependency graph from a file’s declared packages and fetch them from the appropriate repositories. pak is bootstrapped automatically on first use, so you do not need to install it separately.
• renv gives R projects isolated package libraries and lockfiles. ir uses renv’s global package cache to assemble reusable libraries without creating a renv project or lockfile.

ir builds on that stack for non-project workflows: resolving the runtime for a self-describing script or Quarto document, and running or installing command-line entry points distributed by R packages.

A self-describing R script

Here is a complete script:

#!/usr/bin/env -S ir run
#| packages:
#|   - dplyr>=1.0
#|   - tidyr
#| isolated: true
#| exclude-newer: "2024-01-15"

library(dplyr)
library(tidyr)

mtcars |> count(cyl, gear) |> pivot_wider(names_from = gear, values_from = n)

Run it with:

$ ir run script.R

Or, on macOS and Linux, make it executable and run it directly:

$ chmod +x script.R
$ ./script.R

The metadata block is YAML written in #| comments after an optional shebang. ir reads that metadata, resolves the declared packages with pak, materializes a package library with renv, and starts R with the resolved library at the front of .libPaths().

By default, user libraries remain visible as a fallback. Add isolated: true in the file, or use --isolated at the command line, to run without the user library.

Running R package tools with rx

The ir release also includes rx, a short alias for ir tool run that runs executables provided by R packages.

Package authors can expose command-line entry points through standard package subdirectories such as exec/ and bin/. Files in exec/ can be regular Rscript files, Rapp apps, or direct executable scripts. rx resolves the package, finds the requested executable, and runs it in an isolated library.

For example, this resolves the btw CLI from the btw R package on demand and runs btw --help:

$ rx btw --help

# same as:
$ ir tool run btw --help

For tools you use regularly, install them with ir tool install:

# run once
$ ir tool install btw

# now you only need
$ btw --help

Cached by design

The first run of a new dependency set does the normal work of resolving and installing packages. Later runs reuse cached resolutions and content-addressed package libraries when the same requirements are seen again.

That makes ir useful for both one-off and repeated command-line work. You can run a script, run an inline expression, render a report, or launch a package-provided executable without creating a project directory just to hold the dependency state.

ir also bootstraps its own resolver tooling on first use, so you do not need to pre-install pak or renv.

Reproducibility without a project

For R scripts that need more explicit reproducibility, exclude-newer is usually the first thing to reach for:

exclude-newer: 2024-01-15

You can also provide the same date at the command line:

$ ir run --exclude-newer 2024-01-15 script.R

This resolves packages from the Posit Package Manager snapshot for that date. When no other R selector is set, the same date also tells ir to select the latest R minor version available on that date. If you were writing with the current release of R and current CRAN packages, the date alone is usually enough.

Use r-version when the script really needs a specific installed R version or version range. This selection uses rig:

r-version: "4.3"

Together, these options let a file carry the important parts of its runtime requirements without needing a surrounding project. For reproducibility, most files should need only a list of packages and a date.

Quarto documents too

ir uses the same metadata model for Quarto documents. Put package metadata under an ir: key in the document YAML:

---
title: My report
ir:
  packages:
    - dplyr>=1.0
    - gt@1.0
  isolated: true
  exclude-newer: 2025-05-15
---

Then render with:

$ ir render report.qmd
$ ir render report.qmd --to pdf

When ir selects an R executable using --r-version, frontmatter ir.r-version, or date-only exclude-newer, it sets QUARTO_R so Quarto renders with that R. ir also seeds rmarkdown automatically for knitr-based renders unless you declare it yourself.

Python environments too

Some R scripts and Quarto documents also need Python. In an R script, declare the R packages and Python requirements in the same metadata block:

#!/usr/bin/env -S ir run
#| packages:
#|   - reticulate
#| python-packages:
#|   - pandas
#|   - matplotlib
#| python-version: "3.11"
#| exclude-newer: "2026-06-01"

library(reticulate)
pd <- import("pandas")

ir creates the environment with reticulate’s uv-backed environment helper, sets RETICULATE_PYTHON, and activates the environment for subprocesses. Declare reticulate under packages when the R script loads reticulate.

For Quarto, put Python metadata under the document’s ir: key. A knitr document that uses reticulate can mix R and Python requirements:

---
title: My report
ir:
  packages:
    - reticulate
  python-packages:
    - pandas
  exclude-newer: 2025-01-01
---

For a Quarto document that uses the Jupyter engine, the ir: metadata can contain only Python requirements:

---
title: My notebook
jupyter: python3
ir:
  python-packages:
    - matplotlib
    - pandas
  python-version: "3.11"
---

For Quarto renders, ir injects jupyter into the Python environment, passes the resolved interpreter to Quarto with QUARTO_PYTHON, and also sets RETICULATE_PYTHON so documents that use reticulate see the same interpreter. If the document uses the knitr engine and contains Python chunks, ir automatically adds reticulate to the R package manifest.

When Python metadata is present, exclude-newer is also used for Python environment resolution unless python-exclude-newer is set. Use python-exclude-newer when Python packages should use a different snapshot date from R packages.

Install ir

Install a pre-built binary on Linux or macOS:

$ curl -fsSL https://raw.githubusercontent.com/r-lib/ir/main/scripts/install.sh | sh

Install on Windows PowerShell:

> irm https://raw.githubusercontent.com/r-lib/ir/main/scripts/install.ps1 | iex

The installers download the latest GitHub release and install both ir and rx. You can also download release artifacts from the GitHub releases page or with gh release download.

You will also need R / Rscript; rig is required when selecting R by version or by date-only exclude-newer, and Quarto is required when rendering Quarto sources.

Learn more

The project is open source under the MIT license. To get started:

• Read the documentation: https://r-lib.github.io/ir/
• Browse the source: https://github.com/r-lib/ir
• Open an issue: https://github.com/r-lib/ir/issues

This is a first public release, and feedback is especially useful now. If you try ir on your own scripts or Quarto documents, we would like to hear which workflows feel natural, where the metadata model needs more room, and which command-line edges still need smoothing.

If you work across Python and R or juggle multiple projects with different dependency needs, environment management is probably one of the most challenging parts of your workflow. Positron comes with several out-of-the-box ways to help simplify environment management. Here are a few tips to streamline your workflow.

1: Understand how Positron discovers your environment

Positron does not just look at your system PATH. For Python, it actively discovers venv, uv, pyenv, and conda environments. If Positron is not seeing your project’s virtual environment, you can add custom search locations via the python.interpreters.include setting, or trigger a manual rescan with Interpreter: Discover All Interpreters. Learn more about Python discovery in the Positron documentation.

For R, discovery works differently. Positron consults various sources to build the list of R interpreters. These include your PATH, R root folders based on specific operating systems, well-known executable locations, and on Windows the registry. You can customize your R discovery through a few settings including positron.r.customRootFolders and positron.r.customBinaries. Learn more about R discovery in the Positron documentation.

2. Use the Interpreter Selector

To begin your first session, click “Start Session” in the top right corner and select your preferred R or Python interpreter. Positron can run multiple R and Python interpreter sessions at once, but only one is ever the active session at a given moment. The Interpreter Selector always shows you the active session and its status (idle, busy, or shut down) and you can use it to switch between or start additional sessions.

3. Install Python with uv

If Positron does not find a usable Python on your machine, it will offer to install Python via uv to help streamline your setup. If you prefer to manage the installation yourself, you can disable uv with the python.allowUvPythonInstall setting. Check out our blog post exploring on-demand Python installation in Positron or explore configurations in our Python installation documentation.

4. Manage packages with the Packages Pane

The Packages Pane in Positron lets you manage the packages installed in your active session. Whether you use pip, uv, conda, pak, base R, or renv, you can browse installed packages and search package repositories. You can also track outdated packages and install, update, or uninstall packages without leaving Positron or writing any code.

5. View package documentation

If you need to learn more about a specific package, the Packages Pane has buttons to navigate to the source documentation or link to the package’s website. You can also pull up the Help Pane for any reference in the Console using the ? operator, including both packages and functions.

6. Start projects with New Folder from Template

The New Folder from Template flow helps you start new projects faster. Instead of running multiple setup commands you can make a few selections and Positron helps you set up an environment directory, version control, directory structure, and an interpreter instance. Learn more about the Python and R templates available in the documentation.

7. Make use of the Command Palette

We recommend taking advantage of the following commands when managing your environments:

• Interpreter: Discover All Interpreters: Find new interpreters
• Interpreter: Select Session: Select a running interpreter session
• Python: Create Environment: Create a new virtual environment

8. Let Posit Assistant help manage your environment

Posit Assistant has knowledge of your R and Python session including the language, version, names, and types of variables in your environment. You can prompt Posit Assistant to set up environments and troubleshoot issues you run into.

Have an idea for how we can improve environment management in Positron? We would love to hear from you in a discussion on GitHub.

Welcome back to another edition of our monthly Positron updates! Each month we share highlights from our latest release and useful resources. Last release we told you that several major features were on track to leave preview in July, and the time is now here! The new Notebook editor, the Packages pane, and Posit Assistant are all now generally available.

Positron Notebook Editor

Positron’s new Notebook editor is now the default experience for Jupyter (.ipynb) files. This release brings a long list of additions, including split-pane editing, cell tag management, and executing a line or selection within a cell with Cmd/Ctrl+Shift+Enter. You can export notebooks to Quarto, Python, or R, and inline PDF rendering makes it easier to work with generated output. If you are coming from JupyterLab, you will find familiar keyboard shortcuts, and we have improved output fidelity for Mermaid diagrams, htmlwidgets, and ipywidgets.

Posit has built on and for the Jupyter ecosystem for years now, and we are excited to have recently joined the Jupyter Foundation.

Packages pane

The Packages pane has also come out of preview. It gives you a live view of the R and Python packages installed in your active session, so you can search, install, update, and remove packages, and jump to their documentation, without leaving Positron.

This release also makes the pane more capable. Clicking a package opens a detail editor with its overview, metadata, and actions, similar to the Extensions pane. Installing a package searches results as you type, and each row has a button that opens the package’s website. Update indicators appear immediately on a new session from a cached snapshot, and Update All Packages reports exactly what changed. Package operations keep your environment consistent too, resolving against a workspace requirements.txt for Python and updating the renv.lock snapshot for R.

Posit Assistant

Posit Assistant, our unified, data-science-focused approach to AI assistance, is now out of preview and generally available; Posit Assistant fully replaces the legacy Positron Assistant. We know the names are similar, and Joe Cheng recently walked through a bit of the story behind how our AI agent tools have evolved.

This release also gives you finer control over AI in Positron. The new ai.enabled setting turns off every Positron AI feature at once, and administrators can enforce it; notebook.ai.enabled does the same for notebooks specifically. The set of language model providers keeps growing, with DeepSeek joining as an experimental provider and Microsoft Foundry reaching general availability. The configuration modal now shows every provider by default with preview and experimental badges.

Data Explorer

The Data Explorer can now open Excel workbooks directly, with no code required, without first needing to load it via Python or R. Sort, filter, and profile columns, switch between worksheets, and toggle whether the first row holds column names. An Open in Excel button opens the workbook in your native spreadsheet application.

This release broadens what you can open in the Data Explorer overall. Backed by a native DuckDB engine, it now also previews compressed CSV, TSV, and Parquet files. Also, a new Open in Data Explorer code action, from the editor lightbulb or Cmd+., opens the data frame under your cursor in R, Python, and Quarto files, so you can jump straight from your code to exploring your data.

R language intelligence

Last release we introduced within-file symbol resolution for R; this release expands it across files. Go to Definition, Find References, and Rename Symbol now work across the packages and scripts in your workspace, and diagnostics and workspace symbols react to external file changes so your language intelligence stays in sync as your project evolves.

What’s coming next

• New in preview this release, Data Connections lets you browse the schemas, tables, views, and indexes of a database, open tables in the Data Explorer, and generate connection code. It currently supports DuckDB, PostgreSQL, and SQLite. Learn how to try it out and tell us what you think in the Data Connections discussion post: which databases and warehouses you need, whether the connection setup is clear, and anything confusing, missing, or broken.
• We are looking forward to posit::conf(2026) in September, where our team will have several sessions on Positron. Register now to join us in person in Houston or virtually from anywhere in the world.

If you’re new to Python, Positron has a few built-in workflows to help you skip that installation pain entirely. Most of it is powered by uv, created by Astral. We chose uv because it’s fast and has quickly become widely adopted across the Python community. Behind the scenes, uv handles the heavy lifting, downloading Python versions and building environments. Positron wraps that power in a friendly interface, so you never have to remember a command.

From zero to Python in one click

If you don’t have a suitable Python available, Positron will offer to install it for you. When you go to start a Python runtime through the Start Session button, you’ll see an option for + Install Python via uv.

When you choose it, Positron will ask to install uv for you if you don’t already have it. Then it shows you the supported Python versions (currently 3.9 through 3.14) and installs whichever one you pick. If you have a folder open, it will also offer to create a virtual environment for the project and start a Python console session using that environment. Once you have a Python available, this option disappears from the session picker.

If you’d rather not see the prompt to install Python, you can turn it off with the python.allowUvPythonInstall setting (enabled by default).

On-demand Python installation

You don’t have to wait for Positron to ask, either. Open the command palette with Cmd/Ctrl+Shift+P and run Python: Install Python via uv any time you’d like another version. This command will download uv if needed, show you the available Python versions, and optionally offer to create a virtual environment.

Since it runs on demand, it’s a good way to add another interpreter to a project you’ve already set up. And because it follows the same flow every time, it works well for teaching, since everyone ends up in the same place, the same way.

Automatic project setup support

Setting up a virtual environment isn’t limited to that first run. If Positron finds a pyproject.toml or requirements.txt in a project that doesn’t have a virtual environment yet, it’ll offer to create one with uv and install your dependencies. This comes in handy when you’ve cloned a colleague’s project and want to get up and running without extra setup.

If there’s a single requirements source, like a lone requirements.txt or pyproject.toml, Positron will prompt you to create a .venv and install everything right away. And if there are several sources, you can choose which files to include in your installation.

Positron also knows when to stay out of your way. If you already have a local virtual environment, or if you use non-uv files like environment.yml, Pipfile, or poetry.lock, you won’t get a prompt at all.

Try it yourself

Setting up Python doesn’t have to feel like a chore, whether you’re starting on a brand new machine, picking up a colleague’s project, or getting a room full of students ready to code.

Give it a try in Positron’s July 2026 release and let us know what you think.

Welcome to our newsletter, posit::glimpse()!

If you’re currently reading this on our blog, consider subscribing to Product Updates - Open Source on our subscription page to receive this newsletter directly in your inbox.

Welcome to the latest edition of the posit::glimpse() newsletter, the monthly roundup of open-source news for the Posit community. I have many updates for you from across Posit. As my wonderful colleague Kristin Bott stated, “dang this is a productive bunch of humans”.

The table of contents on the right can help you navigate through all the updates. As you scroll, it will open up to show you subcategories →

Announcements

posit::conf(2026) is happening soon!

Our annual conference, posit::conf(2026), is happening September 14-16, and we would love to see you there, whether in Houston or online! Check out the speaker lineup, workshop offerings, and register for posit::conf here.

Tidy Dev Day is happening on September 17, a unique opportunity to collaboratively tackle open-source issues and work directly alongside the very developers who build and maintain the tools you use every day. As Meghan Harris stated about last year’s event, “Tidy Dev Day (TDD) gave me the PERFECT opportunity to explore this further in a low-stress, supportive environment.” Learn more about Tidy Dev Day here.

We’ve joined the Jupyter Foundation

We are proud to announce that we are deepening our commitment to the Jupyter ecosystem by becoming an official Jupyter Foundation Member!

• Learn more in the We’ve Joined the Jupyter Foundation announcement blog post.

Announcing an expanded Posit Academy

We’ve launched a new part of Posit Academy: a free, open library of product courses, hands-on labs, and live workshops available to anyone.

• Learn more in the Announcing an expanded Posit Academy blog post.

Introducing the Posit Impact Awards

Have a story to share? We just launched the Posit Impact Awards to recognize individuals and teams who used Posit to create measurable, meaningful change. Six winners will be selected, one per category, and each will receive a conference-only pass to posit::conf(2026).

• Submit your nomination before July 20th.

Key product updates and new releases

Data visualization and reporting

ggsql 0.4.1

ggsql 0.4.1 introduces spatial plotting capabilities with database-backed geometry processing, supporting WKB format data, 21 map projections for cartographic accuracy, and a built-in Natural Earth world dataset for creating choropleth maps and geographic visualizations with backends like DuckDB spatial, PostGIS, and SpatiaLite.

• Learn more in the ggsql 0.4.1: Spatial plotting and in-layer aggregation blog post.

Ask more of your dashboard with querychat and ggsql

querychat now supports ggsql-powered visualizations, enabling natural language data exploration in dashboards through SQL-only execution (no arbitrary code), with three pre-built tools for visualizing, querying, and filtering data reactively. The package works in both Python and R, integrates with Shiny dashboards, and supports Snowflake Semantic Models for business logic definitions.

• Learn more in the Ask more of your dashboard with querychat and ggsql blog post.

Great Tables 0.22.0

Great Tables v0.22.0 significantly expands Python table presentation capabilities with footnote support, group-wise and grand summary row calculations, column merging utilities for uncertainty and ranges, text transformation methods, value substitution helpers, duration and parts-per formatters, image export functionality via gtsave(), enhanced LaTeX rendering, and makes Pandas an optional dependency for Polars-only workflows. (impressive update!)

• Learn more in the Great Tables v0.22.0 blog post.

Data access

dbplyr 2.6.0

dbplyr 2.6.0 introduces ADBC support via adbi for faster Arrow-based data transfer, JDBC support, new SQL dialect separation, and query composition functions.

• Learn more in the dbplyr 2.6.0 blog post.

webR 0.6.0

webR 0.6.0 upgrades to R 4.6.0 and adds async/await support for JavaScript Promises, curl and httr2 compatibility through WebSocket traffic proxying, modern Fortran fixes for expanded package support, and updated system libraries including OpenSSL 3.5.1 and Emscripten 5.0.7. The release powers interactive R experiences in Quarto Live and Shinylive.

• Learn more in the webR 0.6.0 blog post.

Developer tools and AI

debrief 0.1.0

The debrief package converts profvis profiling output into text-based summaries designed for AI agents, enabling AI-assisted performance optimization by providing structured reports on hotspots, call trees, and memory allocations that AI systems can read and act upon.

• Learn more in the debrief 0.1.0 blog post.

pkgsite 0.1.0

pkgsite 0.1.0 converts R package .Rd documentation files into Quarto .qmd files, enabling custom documentation sites with Quarto’s freeze feature for local example rendering, unified R/Python documentation when combined with Quartodoc, and flexible template customization. The package is available on CRAN and provides an alternative to pkgdown.

• Learn more in the pkgsite 0.1.0 blog post.

watcher 0.2.0

Watcher is a lightweight R package that watches files and directories for changes and reacts in the background. It’s quietly been the engine behind Shiny’s auto-reload for the past year. With the CRAN release of 0.2.0, we’re excited to introduce it as a general-purpose filesystem watcher for R developers.

• Learn more in the watcher 0.2.0 blog post.

Development environment

Air 0.10.0

Air 0.10.0 introduces configurable assignment style enforcement allowing teams to standardize on arrow (<-), equal (=), or preserve existing styles, along with enhanced IDE integrations for Positron and RStudio, multiple installation methods via PyPI and conda-forge, pre-commit hook support, stdin integration for editors, and shell completions.

• Learn more in the Air 0.10.0 blog post.

What’s new in Positron

Positron’s June release includes a lot of highly requested features:

• Inline output for Quarto (one of Positron’s most-requested features ever!)
• Posit Assistant, the successor to Positron Assistant
• Packages pane improvements
• A more customizable interface

For more, check out the Positron June Release Highlights post and subscribe to Positron emails.

Did you know that many of the most upvoted RStudio feature requests are already implemented in Positron? Learn about ten of them in the RStudio’s Top Feature Requests … In Positron blog post!

Machine learning and modeling

brulee 1.0.0

brulee 1.0.0 significantly expands tabular deep learning capabilities in R with five new model architectures, GPU support including Apple Silicon, 32-bit precision for improved performance, and enhanced numerical stability, all integrated with the tidymodels ecosystem.

• Learn more in the brulee 1.0.0 blog post.

CatBoost support in tidymodels

CatBoost gradient boosting support is now available in tidymodels through the boost_tree() interface, providing access to CatBoost’s strong categorical feature handling with full tidymodels integration including hyperparameter tuning, cross-validation, efficient submodel optimization, and orbital package support for SQL generation and in-database predictions.

• Learn more in the CatBoost support in tidymodels blog post.

tidyclust 0.3.0

tidyclust 0.3.0 introduces three new clustering model families and achieves full integration with tidymodels by replacing tidyclust-specific functions with native tune package support.

• Learn more in the tidyclust 0.3.0 blog post.

Event roundup

We were all over the world this month, discussing how to adopt new data tools, get better at old ones, and just loving being part of the community. If you want to learn more about where we were, or see where we’ll be next, check out our event page.

Watch the recordings from some of these events:

Jun 15, 2026 | 34 min | 308 views

Neal Richardson - MCP, or not MCP | Pydata London 26

Neal Richardson - MCP, or not MCP | Pydata London 26 \Model Context Protocol is a standard for defining tools that can be made available to LLMs and AI applications. There’s a lot of noise out there about what you should use to get the best results from AI, so in this talk, I will provide some guidance on when you should use MCP, and when you should reach for some other tool. I will describe cases where MCP is the right tool for the job, and when other things, like skills or other context files, are better. I will also devote attention to questions of security and authentication, which are important for MCP, and provide concrete examples of how MCP servers can be used to unlock agentic workflows while also strengthening data governance. This talk is intended for those who are interested in using LLMs for workflows involving data. No prior experience with MCP is required. Outline: Intro: how can I get data from this API into my Claude Code session? What is MCP? When should you use it, when should you use other tools Work through an example Sharing and deploying MCP servers, alternatives and best practices Optimizing your tools for best results www.pydata.org PyData is an educational program of NumFOCUS, a 501(c)3 non-profit organization in the United States. PyData provides a forum for the international community of users and developers of data analysis tools to share ideas and learn from each other. The global PyData network promotes discussion of best practices, new approaches, and emerging technologies for data management, processing, analytics, and visualization. PyData communities approach data science using many languages, including (but not limited to) Python, Julia, and R. PyData conferences aim to be accessible and community-driven, with novice to advanced level presentations. PyData tutorials and talks bring attendees the latest project features along with cutting-edge use cases. 00:00 Welcome! 00:10 Help us add time stamps or captions to this video! See the description for details. Want to help add timestamps to our YouTube videos to help with discoverability? Find out more here: https://github.com/numfocus/YouTubeVideoTimestamps

Neal Richardson

Python Tutorial Education NumFOCUS PyData Opensource Learn Software Python 3 Julia Coding Learn to Code How to Program Scientific Programming

Jun 26, 2026 | 47 min | 179 views

Agents for Correct, Transparent, and Reproducible Data Analysis - Simon Couch & Sara Altman

Agents for Correct, Transparent, and Reproducible Data Analysis - Simon Couch & Sara Altman (Posit) Abstract: How do we build competent data analysis agents? Data analysis requires a willingness to pause, question conclusions, and dig into subtleties. Frontier LLMs, however, are optimized to push tasks toward completion, not to slow down when something seems off. This tendency works well for coding agents, where success is often verifiable. But for data analysis, verification is more complicated, and autonomous work by the agent can be at odds with the spirit of the discipline. Drawing on our experience building data analysis agents, we’ll share evaluations that expose where LLM-driven analysis goes wrong and design patterns that keep analyses correct, transparent, and reproducible. Resources mentioned in the session: Presentation Slides: https://simonpcouch.github.io/gen-ai-pharma-26 Presentation GitHub repository: https://github.com/simonpcouch/gen-ai-pharma-26 bluffbench: https://github.com/simonpcouch/bluffbench Posit Assistant Terminal (TUI): https://posit-dev.github.io/assistant/docs/downloads/tui/ Posit AI Newsletter: https://opensource.posit.co/tags/ai-newsletter/ Speakers: Simon Couch builds tools that make the work of data science more joyful and effective. As an engineer on the AI Core Team at Posit, his work spans coding agents, model evaluations, inference engineering, and next-edit-suggestion systems. Drawing on his background in statistics, Simon spent several years authoring and maintaining core packages in the open-source tidymodels framework—like stacks, broom, and infer — before shifting his focus to LLMs. He blogs about his work at simonpcouch.com. Simon authors the Posit AI Newsletter along with Sara Altman. Sara Altman is a Senior Developer Advocate on the AI Core team at Posit, where she focuses on how AI can be effectively and responsibly used for data science. Previously, she helped build Posit Academy and taught data science and R at Stanford. Sara authors the Posit AI Newsletter along with Simon Couch. Presented at the 2026 R/Pharma GenAI Day

Sara Altman, Simon Couch

infer tidymodels

Showcases from the community

Brilliant Earth turned their Marketing Mix Model into a Streamlit app deployed on Posit Connect via the Snowflake Native App, so their marketing team can dig into channel performance and run scenario planning on their own. One of the campaigns in the mix: their recent Ring Pop collaboration.

• Check out the spotlight.

Leo Ohyama recently shared a fantastic Lorcana Market Data Analysis & Forecasting dashboard that showcases the power of Python, R, Positron, and Quarto working together.

Leo included detailed documentation in the GitHub repository, a great resource for anyone interested in market forecasting or multi-tool workflows. Thanks for sharing your work with the community, Leo!

• Lorcana dashboard
• Lorcana GitHub repo

We were recently joined by Thomas Lin Pedersen on the Data Science Lab, where he introduced the new ggsql package.

(Almost) immediately after the DS Lab, Dylan Poulsen wrote a blog post on exploring two years of swim data with ggsql! Dylan, we’re convinced you write blogs at the speed of ggsql.

• Exploring the New ggsql Package with Two Years of Swim Data blog post

We usually find these projects on social media. If you’re on LinkedIn, be sure to follow and tag Posit Open Source for us to share the amazing things you’re working on!

What’s next

We’re taking a short break in July before returning with more community hangouts!

• On July 21, Gina Reynolds will join the Data Science Lab (a fun, chill time with live code) to show we can extend ggplot2 by creating our own custom extensions. Register here: https://pos.it/dslab

In the meantime, check out some past Data Science Lab episodes:

May 29, 2026 | 57 min | 1.3k views

Async & Parallel R with {mirai} | Charlie Gao | Data Science Lab

The Data Science Lab is a live weekly call. Register at pos.it/dslab! Discord invites go out each week on lives calls. We’d love to have you! The Lab is an open, messy space for learning and asking questions. Think of it like pair coding with a friend or two. Learn something new, and share what you know to help others grow. On this call, Libby Heeren is joined by Charlie Gao, who walks through async and parallel programming using the mirai package for R. Charlie is the author of {mirai} and {mori}! Charlie demonstrates how mirai lets you run R code in parallel across multiple cores or even distributed across remote machines. He covers the key differences between parallel and async programming, shows how to set up worker daemons (said like “demons”), scale resources dynamically, and connect to remote machines via SSH. Whether you’re running long computations, training models, or building Shiny apps, mirai helps you make the most of your computing resources without blocking your main R session:) Hosting crew from Posit: Libby Heeren, Isabella Velasquez Charlie Gao’s GitHub: https://github.com/shikokuchuo Charlie Gao’s Bluesky: https://bsky.app/profile/shikokuchuo.net Charlie Gao’s LinkedIn: https://www.linkedin.com/in/charliegao/ Charlie Gao’s Mastodon: https://fosstodon.org/@shikokuchuo Resources mentioned in the video and chat: mirai package website: https://mirai.r-lib.org/ mirai GitHub repository: https://github.com/r-lib/mirai AskDeepSeek chatbot for mirai documentation: https://mirai.r-lib.org/ (click “ask deep wiki” button) mirai - Promises (Shiny and Plumber): https://mirai.r-lib.org/articles/v02-promises.html mirai - Serialization: https://mirai.r-lib.org/articles/v03-serialization.html mirai - OpenTelemetry: https://mirai.r-lib.org/articles/v05-opentelemetry.html mirai stop_mirai function: https://mirai.r-lib.org/reference/stop_mirai.html mirai skill for Claude Code: https://github.com/r-lib/mirai/blob/main/.claude/skills/mirai/SKILL.md Plumber2 package: https://plumber2.posit.co/ Daemon (computing) on Wikipedia: https://en.wikipedia.org/wiki/Daemon_(computing) ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh The Lab: https://pos.it/dslab LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Timestamps of Questions / Topics: 00:00 Introduction 03:33 “What is async programming and how is it different from parallel?” 06:57 AskDeepSeek chatbot for the Mirai package 09:40 Setting up the Positron IDE with activity bar on top 15:25 “What was the motivation or need for developing Mirai?” 22:10 Mirai map function for parallel processing 25:25 “Do the contents of Mirai inherit definitions from the global environment?” 29:00 “What’s the difference between Mirai versus promises and future?” 31:50 Demonstrating sequential vs parallel processing 36:00 “Can you use Mirai with HPC?” 37:07 Dynamically scaling workers by adding and removing daemons 38:38 Setting up daemons with URLs for network connections 42:05 Launching workers over SSH to remote machines 43:09 SSH tunneling to connect workers without open ports 51:14 “Does Mirai allow R to perform the same thing as NumPy?” 51:54 “Does Mirai ship with some kind of task viewing dashboard?” 52:35 “Can we use parallel::detectCores() to see how many daemons we can use?” 53:58 “Would parallel processing be more useful than async processing in typical data science work?” 55:00 Mirai skill for Claude Code and AI agents

Charlie Gao

mirai mori plumber plumber2 Positron Shiny

Jun 23, 2026 | 58 min | 4.9k views

Data dictionaries, parquet, & Claude | Hadley Wickham | Data Science Lab

The Data Science Lab is a live weekly call. Register at pos.it/dslab! Discord invites go out each week on lives calls. We’d love to have you! The Lab is an open, messy space for learning and asking questions. Think of it like pair coding with a friend or two. Learn something new, and share what you know to help others grow. On this call, Libby Heeren is joined by Hadley Wickham, who walks through using data dictionaries with Claude Code to clean and document datasets effectively. Hadley demonstrates a workflow using three files: a data cleaning script, a data dictionary in YAML format, and the final cleaned data as a Parquet file. He shows how Claude Code and MCP REPL can help generate and maintain data dictionaries that document what you know about your data, making it easier for both humans and AI agents to work with your datasets. Using the NYC elevators dataset as an example, he walks through data cleaning tasks like normalizing whitespace, handling missing values, fixing date formats, and investigating geocoding issues - all while keeping the data dictionary, cleaning script, and Parquet file in sync through git. Hosting crew from Posit: Libby Heeren, Isabella Velasquez Hadley Wickham’s GitHub: https://github.com/hadley Hadley Wickham’s Bluesky: https://bsky.app/profile/hadley.nz Hadley Wickham’s LinkedIn: https://www.linkedin.com/in/hadleywickham/ Resources mentioned in the video and chat: MCP REPL: https://github.com/posit-dev/mcp-repl Data Dictionary YAML Format Specification: https://github.com/hadley/data-dict.yaml Parquet files in R for Data Science: https://r4ds.hadley.nz/arrow.html#sec-parquet Elevators Dataset Used in Demo: https://github.com/EmilHvitfeldt/elevators Pointblank Package for Data Validation: https://posit-dev.github.io/pointblank/ Arrow R Book: https://arrowrbook.com/ Monaspace Font Family (with ligatures): https://monaspace.githubnext.com/ YAML Multiline Strings Reference: https://yaml-multiline.info/ UBC Course on Shiny with RAG and Parquet: https://ubc-mds.github.io/DSCI_532_vis-2_book/060-03-rag.html Tom Scott Video on Timezones: https://www.youtube.com/watch?v=-5wpm-gesOY Falsehoods Programmers Believe About Names: https://www.kalzumeus.com/2010/06/17/falsehoods-programmers-believe-about-names/ UTC Is Enough for Everyone Right: https://zachholman.com/talk/utc-is-enough-for-everyone-right Daniel Chen’s Cherry Blossom Analysis: https://chendaniely.github.io/posts/2026/2026-03-30-yvr-cherry-blossoms-marathon/ Project Drawdown Climate Impact Explorer: https://drawdown.org/explorer Green Coding Bookdown Resource: https://bookdown.org/content/d1e53ac9-28ce-472f-bc2c-f499f18264a3/ IBM Green Coding Topics: https://www.ibm.com/think/topics/green-coding Secret Elevator in Central Park Article: https://undercovernyc.home.blog/2021/02/08/a-secret-elevator-hidden-in-central-park/ Artificial Cave Beneath Central Park: https://gizmodo.com/an-artificial-cave-200-beneath-central-park-with-micha-1446538828 ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co Hangout: https://pos.it/dsh The Lab: https://pos.it/dslab LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for hanging out with us! Timestamps of Questions / Topics: 00:00 Introduction 03:38 “Can you talk a little bit about what MCP is?” 05:42 Introducing the elevators dataset 07:00 Creating initial data dictionary with Claude 09:03 “Are there any cases where the CSV format is actually a better choice than Parquet?” 09:50 “What font do you use?” 12:02 Adding context from the readme to the data dictionary 14:02 “What is a good way to store data dictionaries along with datasets?” 14:38 “Is this particular data dict YAML format useful for projects with only one table of data?” 17:45 “Is Claude also going to decide when it’s a good time to make a commit?” 24:02 “Does MCP REPL work on a Windows machine and can one use other AI LLM for example ChatGPT with it?” 26:14 Converting date columns to proper date types 27:16 “Do you see a meaningful distinction between data dicts and data contracts?” 29:36 “How do you view your approach to data dictionaries and the development of pointblank?” 34:16 Eliminating placeholder values and using proper missing values 36:25 “Could you show off a diff of a Parquet file?” 38:25 Investigating geocodes and creating a map of elevators 40:20 Using a leaflet map to explore Central Park elevators 42:03 “Which model is Hadley using?” 43:55 Discussion of cost consciousness and environmental impact of LLMs 46:30 “Is there a way to quantify environmental and electrical costs?” 48:50 The mystery elevator in Central Park 54:23 “How do you know this is actually faster or more productive than just writing the code?” 55:45 The importance of deep knowledge of data in qualitative work

Hadley Wickham

bookdown bookdown.org leaflet pointblank Shiny

Feb 19, 2026 | 55 min | 1.7k views

Using R package structure for data science projects | Kylie Ainslie | Data Science Lab

The Data Science Lab is a live weekly call. Register at pos.it/dslab! Discord invites go out each week on lives calls. We’d love to have you! The Lab is an open, messy space for learning and asking questions. Think of it like pair coding with a friend or two. Learn something new, and share what you know to help others grow. On this call, Libby Heeren is joined by Kylie Ainslie who walks through how structuring data science projects as R packages provides a consistent framework that integrates documentation for you and facilitates collaboration with others by organizing things really well. Kylie says, “I stumbled on using an R package structure to organize my projects a number of years ago and it has changed how I work in such a positive way that I want to share it with others! In a world where our attention is constantly being pulled in many directions, efficiency is crucial. Structuring projects as R packages is how I work more efficiently.” Hosting crew from Posit: Libby Heeren, Isabella Velasquez Kylie’s Bluesky: @kylieainslie.bsky.social Kylie’s LinkedIn: https://www.linkedin.com/in/kylieainslie/ Kylie’s Website: https://kylieainslie.github.io/ Kylie’s GitHub: https://github.com/kylieainslie Resources from the hosts and chat: posit::conf(2026) call for talks: https://posit.co/blog/posit-conf-2026-call-for-talks/ Kylie’s posit::conf(2025) talk: https://www.youtube.com/watch?v=YzIiWg4rySA {usethis} package: https://usethis.r-lib.org/ R Packages (2e) book: https://r-pkgs.org/ Paquetes de R (R Packages in Spanish): https://davidrsch.github.io/rpkgs-es/ {box} package: https://github.com/klmr/box extdata docs in Writing R Extensions: https://cran.r-project.org/doc/manuals/R-exts.html#Data-in-packages-1 Tan Ho’s talk on NFL data: https://tanho.ca/talks/rsconf2022-github/ {rv} package: https://a2-ai.github.io/rv-docs/ Whether to Import or Depend: https://r-pkgs.org/dependencies-mindset-background.html#sec-dependencies-imports-vs-depends {pkgdown} package: https://pkgdown.r-lib.org/ Edgar Ruiz’s {pkgsite} package: https://github.com/edgararuiz/pkgsite Attendees shared examples of data packages in the chat! Here they are: https://kjhealy.github.io/nycdogs/ https://kjhealy.github.io/gssr/ https://github.com/deepshamenghani/richmondway https://github.com/kyleGrealis/nascaR.data https://github.com/ivelasq/leaidr ► Subscribe to Our Channel Here: https://bit.ly/2TzgcOu Follow Us Here: Website: https://www.posit.co The Lab: https://pos.it/dslab Hangout: https://pos.it/dsh LinkedIn: https://www.linkedin.com/company/posit-software Bluesky: https://bsky.app/profile/posit.co Thanks for learning with us! Timestamps: 00:00 Introduction 06:17 Reviewing the disorganized project example 10:01 Creating the package structure using create_package 17:50 Organizing external data and scripts in the inst folder 22:55 Adding a README and License 29:06 “What are the advantages to packaging a project?” 33:35 Writing Roxygen2 documentation 36:06 “Do you type return at the end of your functions?” 41:55 Handling dependencies with use_package 43:53 “Can you just use require(dplyr) at the top?” 47:45 Setting up a pkgdown site 50:11 Creating vignettes 52:22 “What is the role of the usethis package?” 54:18 Loading the package with devtools::load_all

Edgar Ruiz

devtools dplyr pkgdown roxygen2 usethis

I’m a real person, and I would love to know how to make the Glimpse newsletter better! Find me on LinkedIn and Bluesky, or email me at isabella [dot] velasquez [at] posit.co.

This post walks through the major additions. The package’s fundamentals have not changed (stores, chunkers, retrievers, and the pattern for connecting to chatlas all work as before), but the surface area for building and maintaining stores in production has grown substantially.

The crawl and ingest API

The largest change in v0.2 is a new API for crawling sources and ingesting them into a store. In v0.1, building a store meant calling read_as_markdown() on individual URLs, chunking each result, and upserting them one by one. That works for a handful of pages, but it becomes unwieldy for larger collections, where you also want caching (to avoid re-fetching unchanged content) and concurrency (to finish in minutes rather than hours).

The new API introduces a clean separation between crawling and storage. On the crawl side, a crawler object produces MarkdownDocument objects from a defined scope. On the store side, store.ingest() consumes those documents lazily, applies an optional preparation step (typically chunking), and writes them to the store with configurable parallelism. The pipeline looks like this:

from raghilda.chunker import MarkdownChunker
from raghilda.crawl import CrawlScope, WebCrawler
from raghilda.embedding import EmbeddingOpenAI
from raghilda.store import DuckDBStore

crawler = WebCrawler(cache_dir=".cache/crawl", max_workers=4)

scope = CrawlScope(
    roots=["https://example.com/docs"],
    include_patterns=["https://example.com/docs/**"],
    depth=2,
)

documents = crawler.markdown_documents(scope)

store = DuckDBStore.create(
    location="raghilda.duckdb",
    embed=EmbeddingOpenAI(),
    overwrite=True,
)

summary = store.ingest(
    documents,
    prepare=MarkdownChunker(chunk_size=1000).chunk,
    max_workers=4,
)

print(summary)

IngestSummary(inserted=142, replaced=0, skipped=0)

The CrawlScope dataclass defines the traversal policy: root URLs, include/exclude patterns, depth limits, and page count caps. The crawler handles the mechanics of fetching and converting pages to Markdown, while the scope tells it where to go. This separation means you can change the backend (swap WebCrawler for CloudflareCrawler, for instance) without redefining the scope, and vice versa.

Three concrete crawlers ship with v0.2. DirectoryCrawler walks local file trees and converts supported formats to Markdown. WebCrawler fetches pages over HTTP using requests and converts them locally. CloudflareCrawler delegates both fetching and rendering to Cloudflare’s Browser Rendering API (the right tool for sites that load content through JavaScript). All three implement the same interface: origins() to discover pages, fetch_raw() and fetch_markdown() for single-page access, and markdown_documents() for the full pipeline.

Caching is built into the crawler layer. When you pass cache_dir=True (or an explicit path), each crawler stores fetched content and converted Markdown in a flat directory of files with metadata sidecars. On subsequent runs, cached entries are reused if they are still fresh. For WebCrawler and CloudflareCrawler, freshness is controlled by cache_stale_after=, a timedelta that defines how long a cached entry remains valid. This makes interrupted workflows resumable without any explicit checkpoint logic: rerun the script and the cache supplies everything that was already fetched, while only new or stale pages trigger network requests.

Concurrency operates on both sides of this boundary independently. The crawler can fetch and convert pages in parallel (controlled by max_workers= on the crawler constructor), and store.ingest() can write to the store concurrently (controlled by its own max_workers= argument). For WebCrawler, the breadth-first frontier is explored concurrently while preserving stable output order, so results come back in a consistent sequence regardless of which pages respond first.

CloudflareCrawler

The CloudflareCrawler moves the work of a crawl off the local machine. Instead of fetching pages and converting them to Markdown with local processes, it hands both jobs to Cloudflare’s Browser Rendering API, so a long crawl over a large site runs on Cloudflare’s distributed infrastructure rather than competing for local CPU and bandwidth. For collections large enough that concurrent local requests become the bottleneck, this is the primary reason to reach for it: the slow, sustained part of building a store happens remotely, and what returns is ready-to-chunk Markdown. The same arrangement resolves a problem that defeats a plain HTTP fetch, because the API renders each page in a real browser, executing JavaScript and waiting for the DOM to settle before extracting content. Sites built with React, Vue, or Angular, which an ordinary request reduces to an empty shell, are therefore handled without extra configuration or a locally installed headless browser.

The usage looks almost identical to WebCrawler, because both share the same crawl interface. The key difference is that the constructor takes Cloudflare credentials instead of an HTTP session, and Cloudflare’s infrastructure handles the rendering remotely (so there is no need to install Playwright, Selenium, or any other local headless browser):

import os
from raghilda.crawl import CloudflareCrawler, CrawlScope

crawler = CloudflareCrawler(
    account_id=os.environ["CLOUDFLARE_ACCOUNT_ID"],
    api_token=os.environ["CLOUDFLARE_API_TOKEN"],
    cache_dir=True,
    render=True,
    max_workers=4,
)

scope = CrawlScope(
    roots=["https://my-spa-docs.example.com/"],
    depth=2,
    include_patterns=["https://my-spa-docs.example.com/**"],
    limit=500,
)

documents = crawler.markdown_documents(scope)

Iterating the result performs the crawl lazily, yielding one MarkdownDocument per page. Each document exposes the page’s origin alongside its rendered Markdown content, so a quick pass confirms that the JavaScript-rendered pages came back with real text rather than the empty shells a plain HTTP fetch would have produced:

for doc in documents:
    print(doc.origin, f"({len(doc.content):,} chars)")

https://my-spa-docs.example.com/ (3,214 chars)
https://my-spa-docs.example.com/guide/install (5,902 chars)
https://my-spa-docs.example.com/guide/config (8,477 chars)
https://my-spa-docs.example.com/api/reference (12,043 chars)

The render=True default tells Cloudflare to execute JavaScript before extracting content. For server-rendered sites where JavaScript execution is unnecessary, setting render=False reduces crawl time and API usage. The source= parameter controls how pages are discovered: "all" (the default) combines multiple discovery methods, "sitemap" reads from the site’s sitemap.xml, "crawl" follows links from the rendered DOM, and "urls" processes only the explicitly provided roots.

For stores that need regular updates, the modified_since= parameter restricts the crawl to pages modified after a given Unix timestamp, keeping refresh jobs lightweight. Combined with the crawl cache and the store’s own deduplication (identical documents are not re-embedded), an incremental update script can run daily without redundant work:

import time
from datetime import timedelta

one_week_ago = int(time.time()) - (7 * 24 * 60 * 60)

crawler = CloudflareCrawler(
    account_id=os.environ["CLOUDFLARE_ACCOUNT_ID"],
    api_token=os.environ["CLOUDFLARE_API_TOKEN"],
    cache_dir=True,
    cache_stale_after=timedelta(days=1),
    modified_since=one_week_ago,
)

The tradeoff is cost: CloudflareCrawler requires a Cloudflare account with Browser Rendering access. For static HTML sites where a plain HTTP fetch returns the full content, WebCrawler remains the simpler and free option. Both crawlers share the same interface, so switching between them requires only a constructor change.

PostgreSQL store

raghilda v0.1 shipped with three store backends: DuckDB (local, zero-config), ChromaDB, and OpenAI Vector Stores. v0.2 adds PostgreSQLStore, backed by psycopg2 and pgvector. This is the natural choice for production deployments where the store needs to be shared across services, or where you already have PostgreSQL infrastructure.

from raghilda.store import PostgreSQLStore
from raghilda.embedding import EmbeddingOpenAI

store = PostgreSQLStore.create(
    connection="postgresql://user:pass@localhost:5432/mydb",
    embed=EmbeddingOpenAI(),
    name="docs_store",
    overwrite=True,
)

The store supports full-text search via PostgreSQL’s native tsvector/tsquery with a pre-computed column and GIN index, vector similarity search via pgvector with HNSW indexes (supporting cosine, L2, and inner product distance metrics), and combined retrieval that merges both result sets with deoverlap support.

Retrieval uses the same interface as every other backend: a single retrieve() call returns a ranked list of chunks, each carrying its similarity score under metrics and its heading-hierarchy context. Running a query against a store populated with the raghilda documentation returns the most relevant chunks first:

results = store.retrieve("How are vector indexes configured?", top_k=2)

for r in results:
    print(f"Score: {r.metrics[0].value:.4f}")
    print(r.context)
    print(r.text)
    print("---")

Score: 0.5142
# PostgreSQL store
Vector similarity search runs through pgvector with HNSW indexes,
supporting cosine, L2, and inner product distance metrics. Call
build_index() after ingestion to create them.
---
Score: 0.4417
# PostgreSQL store > Combined retrieval
Combined retrieval merges the vector and full-text result sets and
applies deoverlap to drop redundant overlapping chunks, returning a
single ranked list from one retrieve() call.
---

Attributes work as expected: scalar types map to columns, struct types map to JSONB, and attribute filters can query into JSONB fields using the ->> operator. The build_index() method creates HNSW indexes after ingestion, and the vss_index= parameter on create() controls the default index type.

Connection strings are accepted directly in create() and connect(), so you can point the store at any PostgreSQL instance with pgvector installed. If the pgvector extension is missing, the store raises an informative error rather than failing cryptically on the first vector operation.

NVIDIA NIM embeddings

The embedding layer gains a new provider: EmbeddingNVIDIA, which connects to NVIDIA’s OpenAI-compatible embedding API. The default model is nvidia/llama-nemotron-embed-1b-v2, a compact embedding model suitable for retrieval workloads. The provider reads its API key from the NVIDIA_API_KEY environment variable.

from raghilda.embedding import EmbeddingNVIDIA

embedding = EmbeddingNVIDIA()

One notable feature of NVIDIA’s embedding API is differentiated input types: queries and documents are embedded with different prefixes ("query" and "passage"), which can improve retrieval quality for asymmetric search where the query is short and the documents are long. raghilda handles this distinction automatically when the store calls the embedding provider during ingestion and retrieval.

The provider includes built-in rate limit handling with exponential backoff. NVIDIA’s 429 responses carry no Retry-After header or rate limit metadata, so backoff is the only viable strategy. For users who want to keep embedding computation entirely local, NVIDIA NIM can also be self-hosted, in which case you point the provider at your local endpoint with a base_url= override.

Improved DuckDB error messages

A smaller but practical improvement: DuckDBStore now raises clear, actionable errors when BM25 retrieval is attempted before the index has been built, or after writes have made the index stale. Previously, this produced a cryptic CatalogException from DuckDB about a missing match_bm25 function. The new message tells you exactly what to do:

RuntimeError: DuckDBStore retrieval requires a current BM25 index.
Call `store.build_index("bm25")` after inserting or updating documents
and before calling `retrieve_bm25()` or `retrieve()`.

The store now tracks BM25 freshness internally: the index is marked stale after any upsert() call and marked current after build_index("bm25"). This tracking happens off the retrieval hot path, so there is no per-query overhead. HNSW indexes are unaffected because DuckDB maintains them across writes automatically.

Why even use raghilda?

raghilda is a retrieval library, not an orchestration framework. Larger projects like LangChain and LlamaIndex offer composable retrieval components too, but they also ship agent runtimes, chain abstractions, prompt management, and memory systems. If all you need is the retrieval pipeline (crawl, chunk, embed, store, retrieve), raghilda gives you that without the surrounding framework. The API surface is small: plain dataclasses, iterators, and direct function calls. There are fewer layers of indirection between your code and the underlying operations, which makes the pipeline easier to debug and reason about.

raghilda v0.2 makes that focused scope practical at scale. The crawl API adds caching and concurrency while keeping each step a separate, inspectable call. The storage layer lets you start with a local DuckDB file and move to PostgreSQL or OpenAI Vector Stores later without changing retrieval code. And every backend provides hybrid retrieval (semantic search, BM25, and attribute filtering combined in a single retrieve() call) out of the box, without assembling separate retriever classes or configuring a pipeline graph.

Getting started

raghilda v0.2 is available now on PyPI (pip install raghilda). The raghilda documentation site covers all of the features described here in more detail. The Getting Started guide walks through building a store from scratch, and the Crawling and Ingestion guide covers the new crawl API in depth. A dedicated CloudflareCrawler guide explains browser rendering, page discovery, caching, and incremental updates. The GitHub repository has the source, issue tracker, and full changelog. If you run into problems or have feature requests, open an issue there.

The v0.22.0 release is the largest step in that direction so far. It introduces footnotes, group-wise summary rows, a family of column-merging methods, a suite of text transformations, several value-substitution helpers, two new formatting methods, and a modern image-export pipeline through gtsave(). The LaTeX output gained the ability to render stubs and row groups, and Pandas is no longer a required dependency. There is a great deal to cover, so this post walks through each addition in turn, with a small working example for every one.

Footnotes with tab_footnote()

Footnotes are one of the oldest conventions in tabular presentation, and they solve a real problem: sometimes a value, a label, or a heading needs a short explanation that would clutter the table if placed inline. The new tab_footnote() method attaches a footnote to any location in the table and manages the marks for you, numbering them sequentially in the order they appear and collecting the notes themselves in the table’s footer.

A location is specified with one of the loc.* helpers, the same ones used elsewhere in the library for styling. You can attach a note to cells in the stub, to a column label, to the subtitle, or to body cells. Because the footnote text accepts md() and html(), you can format it with Markdown or raw HTML just as you would any other piece of table content.

import polars as pl
from great_tables import GT, loc, md
from great_tables.data import towny

towny_mini = (
    pl.from_pandas(towny)
    .filter(pl.col("csd_type") == "city")
    .select(["name", "density_2021", "population_2021"])
    .top_k(10, by="population_2021")
    .sort("population_2021", descending=True)
)

(
    GT(towny_mini, rowname_col="name")
    .tab_header(
        title=md("The 10 Largest Municipalities in `towny`"),
        subtitle="Population values taken from the 2021 census.",
    )
    .fmt_integer()
    .cols_label(density_2021="Density", population_2021="Population")
    .tab_footnote(
        footnote="Part of the Greater Toronto Area.",
        locations=loc.stub(rows=[
            "Toronto", "Mississauga", "Brampton", "Markham", "Vaughan"
        ]),
    )
    .tab_footnote(
        footnote=md("Density is in terms of persons per {{km^2}}."),
        locations=loc.column_labels(columns="density_2021"),
    )
    .tab_footnote(
        footnote="Census results made public on February 9, 2022.",
        locations=loc.subtitle(),
    )
    .opt_footnote_marks(marks="letters")
)

The marks themselves are configurable through opt_footnote_marks(). The default is a standard set of typographic symbols, but you can switch to numbers or letters, as we did above with marks="letters". The placement= argument on tab_footnote() controls whether a mark sits to the left or right of the cell content, and the default "auto" chooses a side based on the cell’s alignment.

Group-wise summaries with summary_rows()

When a table is divided into row groups, readers frequently want a per-group summary: a total, a mean, a minimum and maximum. The summary_rows() method computes these and inserts them as labeled rows within each group, either at the bottom (the default) or at the top.

The aggregations are described with the fns= argument, a dictionary whose keys become the row labels and whose values are the expressions to evaluate. The expressions can be Polars expressions, which is the most concise option when your data is a Polars DataFrame, or plain Python callables that receive a DataFrame subset. A formatting function from the vals.* family can be passed through fmt= so that the summary values match the formatting of the rest of the table.

import polars as pl
from great_tables import GT, vals
from great_tables.data import gtcars

gtcars_mini = (
    pl.from_pandas(gtcars)
    .select(["mfr", "model", "hp", "trq"])
    .head(12)
)

(
    GT(gtcars_mini, rowname_col="model", groupname_col="mfr")
    .summary_rows(
        fns={
            "Min": pl.col("hp", "trq").min(),
            "Max": pl.col("hp", "trq").max(),
        },
        fmt=vals.fmt_integer,
    )
)

By default the summary applies to every group, but the groups= argument narrows it to a named subset when you only need summaries in certain places. The release also includes grand_summary_rows(), a companion method that produces a single summary across the entire table rather than one per group. Both kinds of summary can be targeted for styling through loc.summary() and loc.grand_summary(), so you can shade them or set them apart from the regular body rows.

Merging columns together

Tables often hold several columns that, conceptually, describe a single quantity. A value and its uncertainty, the lower and upper ends of a range, or a count paired with its percentage all read better as one column than as two. The release adds a family of merge methods for exactly these situations, along with a generic method for everything else.

The most specialized of these is cols_merge_uncert(), which combines a measured value with its uncertainty and renders the pair with a plus-or-minus separator. You provide the value column and the uncertainty column, and the second column is hidden automatically once it has been folded into the first.

from great_tables import GT
from great_tables.data import exibble
import polars as pl

exibble_mini = (
    pl.from_pandas(exibble)
    .select("num", "currency")
    .slice(0, 7)
)

(
    GT(exibble_mini)
    .fmt_number(columns="num", decimals=3, use_seps=False)
    .cols_merge_uncert(col_val="currency", col_uncert="num")
    .cols_label(currency="value + uncert.")
)

The cols_merge_range() method works the same way for a pair of columns that mark the beginning and end of a range, joining them with an en dash by default (the separator is adjustable through sep=). The cols_merge_n_pct() method pairs a count with a percentage, rendering values in the familiar 10 (16.70%) form and suppressing the percentage when the count is zero.

from great_tables import GT
import polars as pl

df = pl.DataFrame({
    "category": ["A", "B", "C"],
    "n": [10, 20, 30],
    "pct": [0.167, 0.333, 0.500],
})

(
    GT(df)
    .fmt_percent(columns="pct")
    .cols_merge_n_pct(col_n="n", col_pct="pct")
    .cols_label(n="Count (%)")
)

For anything that does not fit those three patterns there is the generic cols_merge(), which takes a list of columns and a pattern= template. The template uses zero-based indices in braces to refer to the columns, so a pattern of "{0} to {1}" interleaves the first and second columns with the literal text between them. The first column named becomes the visible, merged column, and the rest are hidden by default. This is the general mechanism on which the specialized methods are built, and it is the right tool when your desired arrangement is unusual.

A related convenience is cols_reorder(), which rearranges every column in a single call. Previously, a full reordering meant a sequence of cols_move_*() invocations; now you can list the columns in the order you want and have the table laid out accordingly. The method expects every column to appear exactly once, raising an error if any are omitted or duplicated, which guards against the silent loss of a column.

from great_tables import GT
from great_tables.data import exibble

exibble_mini = exibble[["num", "char", "fctr", "date", "time"]]

(
    GT(exibble_mini)
    .cols_reorder(["fctr", "date", "time", "char", "num"])
)

A suite of text transformations

Formatting methods handle numbers, dates, and currencies, but cell content sometimes needs a transformation that no formatter anticipates. The release introduces four text_*() methods that operate on the rendered text of cells, each addressing a different shape of problem.

The most general is text_transform(), which applies an arbitrary function to the text of the targeted cells. The function receives the cell’s current string and returns a new one, which makes it suitable for any transformation you can express in Python. Because it runs after formatting, you can format a value first and then decorate the result.

from great_tables import GT, loc, exibble

(
    GT(exibble[["num", "char"]].head(4))
    .fmt_number(columns="num", decimals=2)
    .text_transform(
        locations=[loc.body(columns="num"), loc.body(columns="char")],
        fn=lambda x: f"~ {x}",
    )
)

When the transformation is a regular-expression substitution, text_replace() is more direct. It takes a pattern= and a replacement=, and it supports capture groups, so you can wrap or rearrange matched text. The example below finds parenthetical text and emphasizes it with HTML tags.

import pandas as pd
from great_tables import GT, loc

df = pd.DataFrame({
    "item": ["Column A (details)", "Column B (info)"],
    "value": [1, 2],
})

(
    GT(df)
    .text_replace(
        pattern=r"\((.+?)\)",
        replacement=r"(<em>\1</em>)",
        locations=loc.body(columns="item"),
    )
)

The remaining two methods cover conditional replacement. text_case_match() is a switch-like construct: each case is a tuple pairing one or more values to match against a replacement string, with an optional default= for everything unmatched. text_case_when() generalizes this to predicates, where each case pairs a function that returns a boolean with the replacement to use when it is true. The case ordering matters, since the first matching predicate wins, which makes it a natural fit for binning a numeric column into labels.

import pandas as pd
from great_tables import GT, loc

df = pd.DataFrame({"score": [95, 72, 88, 61, 100]})

(
    GT(df)
    .fmt_number(columns="score", decimals=0)
    .text_case_when(
        (lambda x: int(x) >= 90, "A"),
        (lambda x: int(x) >= 80, "B"),
        (lambda x: int(x) >= 70, "C"),
        default="F",
        locations=loc.body(columns="score"),
    )
)

Substituting specific values

Closely related to text transformation is the act of replacing particular values for the sake of readability. A column of measurements might contain values too small to be meaningful, or zeros that would be better shown as a dash, or missing entries that should read as something other than a blank. The release adds a family of sub_*() methods for these cases: sub_missing() for missing values, sub_zero() for zeros, sub_small_vals() and sub_large_vals() for values beyond a threshold, and the general sub_values() for replacing any specified value.

The small-value substitution is representative. It replaces values whose magnitude falls below a threshold= with a chosen pattern, which is useful when very small numbers carry no real information and only distract. The sign= argument restricts the substitution to positive or negative values, so you can treat the two tails of a distribution differently.

from great_tables import GT
import polars as pl

neg_vals_df = pl.DataFrame({
    "i": range(1, 6),
    "numbers": [-0.0001, -0.005, -0.05, -1.0, -100.0],
})

(
    GT(neg_vals_df)
    .fmt_number(columns="numbers")
    .sub_small_vals(sign="-", threshold=0.01, small_pattern="~0")
)

These methods operate on the underlying values rather than on rendered text, so they compose cleanly with the formatting methods. You decide what counts as missing, zero, small, or large, and the table presents those cases consistently wherever they occur.

Two new formatters: durations and parts-per

The formatting family gained two members. The first, fmt_duration(), renders durations in any of several styles. Numeric inputs are interpreted according to an input_units= setting (seconds, minutes, hours, days, or weeks), while Polars Duration columns are detected automatically. The duration_style= argument selects between a narrow style such as 5d 3h, a wide style such as 5 days, 3 hours, a colon-separated style such as 02:15:30, and ISO 8601. The example below renders race times as zero-padded HH:MM:SS.

import pandas as pd
from great_tables import GT

df = pd.DataFrame({
    "event": ["Marathon", "Half Marathon", "10K", "Mile"],
    "winning_time_s": [7377, 3542, 1620, 233],
})

(
    GT(df)
    .fmt_duration(
        columns="winning_time_s",
        input_units="seconds",
        duration_style="colon-sep",
        output_units=["hours", "minutes", "seconds"],
    )
)

The second formatter, fmt_partsper(), handles parts-per quantities: per-mille, parts per million, parts per billion, and finer scales still. The to_units= argument names the target quantity, the values are scaled to match unless you opt out with scale_values=False, and the symbol is rendered appropriately for both HTML and LaTeX output. The example formats gas concentrations as parts per billion by volume.

import polars as pl
from great_tables import GT

concentrations = pl.DataFrame({
    "gas": ["CO", "NO2", "O3"],
    "conc": [1.5, 35.0, 120.0],
})

(
    GT(concentrations)
    .fmt_partsper(
        columns="conc",
        to_units="ppb",
        scale_values=False,
        symbol="ppbV",
    )
)

Saving tables as images with gtsave()

A display table is often destined for a slide deck, a report, or a README, and in those settings you need an image rather than live HTML. The new gtsave() method produces one by rendering the table in a headless instance of Chrome and capturing it. It writes PNG, JPEG, WebP, and PDF, choosing the format from the file extension you supply.

from great_tables import GT
from great_tables.data import gtcars
import polars as pl

gtcars_mini = (
    pl.from_pandas(gtcars)
    .select(["mfr", "model", "msrp"])
    .head(5)
)

(
    GT(gtcars_mini)
    .tab_header(title="Some Cars from gtcars")
    .fmt_currency(columns="msrp")
    .gtsave("my_table.png")
)

Several arguments control the capture. The zoom= factor governs the resolution of raster output, with higher values producing sharper images, while expand= adds padding around the table and vwidth=/vheight= set the viewport. The gtsave() method replaces the older save(), which is now deprecated; existing code will continue to work for the time being, but new work should use gtsave().

Better LaTeX output

Great Tables can render to LaTeX as well as HTML, and that path received substantial attention in this release. LaTeX output now supports the stub and row groups, including spanning column headers and the row-group-as-column layout, which means that tables relying on these structural features are no longer limited to HTML. In addition, Markdown and HTML content placed in cells, headers, or footnotes is now converted to its LaTeX equivalent during rendering, so styled text survives the trip into a LaTeX document rather than appearing as literal markup. For anyone producing tables destined for a paper or a typeset report, the LaTeX output is now much closer in capability to the HTML output.

Polars without Pandas

Until now, Great Tables required Pandas even if all of your work was in Polars. As of this release, Pandas is an optional dependency, and the library is fully functional with Polars alone. For Polars-first projects and for lightweight environments where every dependency counts, this removes a sizable transitive install that was not actually needed. Pandas users are unaffected: a DataFrame from either library works as input exactly as before, and the choice of backend remains yours.

Getting started

Great Tables v0.22.0 is available now on PyPI, so a pip install great-tables (or an upgrade of an existing install) brings everything described here. The documentation site, which moved to Great Docs as its generator in this release, covers each method in detail with runnable examples, and the User Guide has been updated to reflect the new features. The GitHub repository holds the source, the full changelog, and the issue tracker. This release also welcomed several first-time contributors, and if you would like to join them, or simply have a feature to request or a bug to report, the issue tracker is the place to start.

Since its inception, Project Jupyter has grown into one of the world’s most widely used open source ecosystems for interactive computing, powering breakthroughs in research, education, and industry. The Jupyter Foundation, hosted by the Linux Foundation, was established to support the long-term sustainability of this work by bringing together organizations committed to investing in the project’s future.

By joining as a Foundation Member, we are becoming active stewards of its future. Our membership helps fund the core infrastructure, the release engineering, and the community events that keep Jupyter at the cutting edge of scientific computing. This move reinforces our promise to the open source community: we will not only build on these tools, but we will also build up the people and processes that create them.

Open source is a shared resource, and it requires shared responsibility. We encourage our partners and peers in the industry to join us in supporting the foundations that make our work possible.

To learn more about our commitment to open research and technical innovation, visit our About Page.

1. Visualize: execute ggsql queries, rendered as visualizations in the chat.
2. Query: execute SQL queries, rendered as tables/text in the chat.
3. Filter: execute filter SQL queries on predetermined views, allowing the LLM to reactively drill into the data in response to user questions.

Equipped with these tools, your dashboard can offer a balance between “curated insights” and “explorable data” — surfacing interesting trends and summaries upfront, but also letting users ask follow-up questions that go beyond the predetermined views. The video below gives you a feel for this workflow in action¹. Note how the conversation starts off by filtering the predetermined views, but then progresses into more general exploration.

Crucially, every one of querychat’s tools works by executing SQL (or ggsql) — never arbitrary code. Every query is also fully visible and reproducible: users can inspect the code behind any response, and copy it to run independently. In the next version of querychat, you can also expect to see a rich export capability, allowing you to save the insights you care about in a format you care about (e.g. a Quarto dashboard, Jupyter notebook, or R Markdown file).

Restricting querychat’s code execution capability to SQL (or ggsql) is an intentional design choice. We can guarantee that querychat does not run arbitrary R or python code, making it viable for production environments where security and control are required. As a result, querychat may not be as capable as a general coding assistant like Posit Assistant, but you generally don’t want production apps that let users execute arbitrary code. By focusing on SQL execution, querychat can maintain a strong security posture while still enabling useful exploration of data via natural language.

Get started

Getting started is as easy as pointing QueryChat() at your data source and getting set up with an LLM. Although we recommend frontier models for an ideal experience, open-weight models have recently become quite capable, and can be a great way to get started without needing API access or incurring costs.

For this article, I’m using LMStudio to run google/gemma-4-26b-a4b locally on my fairly standard MacBook Pro. If you prefer a different LLM or provider, refer to the docs (R) to see how to configure.

Once you’ve picked an LLM, next step is ensuring both querychat and ggsql are installed. Here we’ll also use the palmerpenguins data set to keep examples lightweight and self-contained, but you can point querychat at anything from a data frame to a remote database connection (R).

pip install "querychat[viz]" palmerpenguins

install.packages(c("querychat", "ggsql", "palmerpenguins"))

Basic usage

Once installed, you can get a basic chat UI using the code below. We’ll include just the query and visualize tools here since the filter tool is designed to work in the context of a larger dashboard, which we’ll cover in the next section.

from shiny.express import ui
from querychat.express import QueryChat
from palmerpenguins import load_penguins

qc = QueryChat(
    load_penguins(), 
    "penguins", 
    client="lmstudio/google/gemma-4-26b-a4b",
    tools=("query", "visualize")
)

qc.ui()

ui.page_opts(fillable=True)

shiny run app.py

library(shiny)
library(querychat)
library(palmerpenguins)

qc <- QueryChat$new(
  penguins,
  client = "lmstudio/google/gemma-4-26b-a4b",
  tools = c("query", "visualize")
)

ui <- bslib::page_fillable(qc$ui())
server <- function(input, output, session) { qc$server() }
shinyApp(ui, server)

shiny::runApp("app.R")

Upon opening the app, the LLM greets us with a welcome message tailored to the data source we’ve provided:

Query tool

For questions addressable via numerical summaries, the LLM requests the query tool with relevant SQL. The LLM may also choose to collapse details of the tool call, especially when it decides to weave the results within its actual response. That said, full details can always be inspected by clicking on the “Query Data” tool call display:

Visualize tool

For questions that are better suited to a visual response, the LLM requests the visualize tool with relevant ggsql. In addition to rendering the plot inline for the user to see, that same plot is also provided to the LLM so that it can interpret the result:

A couple noteworthy things about this experience:

• The footer includes options to view the underlying ggsql query, download the plot as an image, and expand the display to full screen.
• Plots are always shown by default, but can be collapsed by clicking the header.

This hopefully gives you a taste for how easy it is to get set up with a basic querychat UI and start asking questions of your data. You may, however, be wondering how querychat is able to produce correct queries and how the code execution actually works. Let’s dive into those details next.

How does it work?

Execution

One important thing to understand about querychat is that the LLM itself is not handling the SQL execution – querychat is. Where that execution ultimately happens depends on what data source you’re providing. If you’re pointing querychat at an in-memory data frame, the execution happens in-process using DuckDB. If you’re pointing it at a database connection, the execution happens against that database. In either case, the LLM is generating queries based on its understanding of the data schema and any additional context you’ve provided, not the actual data. This separation is what allows querychat to maintain a strong security posture, scale to large data, and deliver a good user experience.

Schema discovery

To elaborate on what “understanding of the data schema” actually means: when you point querychat at a data source, it automatically extracts column names, types, numerical ranges, and categorical values. This information is included in the system prompt for the LLM, so it has a clear picture of what the data looks like and can generate accurate queries without needing to see the actual data. For many datasets, this is enough to get good results out of the box.

Additional context

For more complex datasets or domain-specific questions, you can also provide additional context through a plain-text data description. querychat now also automatically picks up on Snowflake Semantic Models when connected to a Snowflake database, giving the LLM access to authoritative definitions of business logic and metrics without any manual configuration. We hope to add more integrations to other semantic layer formats in the future.

To learn more, querychat’s website has more details on data sources (R), providing context (R), and tool execution (R).

Chat-driven dashboards

A chat interface alone likely isn’t the experience you want to ship to end users — the better pattern is to surface interesting findings first, then let users explore beyond them. This is where querychat begins to really shine: the chat interface we already covered can easily be embedded inside of a larger app that includes other outputs – plots, tables, value boxes, etc. querychat comes with another tool designed for this use case – the filter tool – allowing the LLM to effectively drill down into relevant sections of the data in the dashboard in response to user questions.

The key integration point is df(), a reactive value that reflects the current state of the data after any filtering applied by the LLM. Use df() as the data source for your plots, tables, and value boxes, and they’ll automatically update in response to user questions in the chat.

from shiny.express import render, ui
from querychat.express import QueryChat
from palmerpenguins import load_penguins
from faicons import icon_svg

qc = QueryChat(
    load_penguins(),
    "penguins",
    client="lmstudio/google/gemma-4-26b-a4b",
    tools=("filter", "query", "visualize")
)

qc.sidebar()

with ui.layout_columns(fill=False):
    with ui.value_box(showcase=icon_svg("binoculars")):
        "Penguins"
        @render.text
        def count():
            return len(qc.df())

    with ui.value_box(showcase=icon_svg("fingerprint")):
        "Species"
        @render.text
        def species():
            return qc.df()["species"].nunique()

    with ui.value_box(showcase=icon_svg("gauge-high")):
        "Avg Body Mass"
        @render.text
        def avg_mass():
            return f"{qc.df()['body_mass_g'].mean():.0f}g"

with ui.layout_columns():
    with ui.card():
        ui.card_header("Bill Dimensions")
        @render.plot
        def scatter():
            import plotnine as p9
            
            return (
                p9.ggplot(qc.df(), p9.aes("bill_length_mm", "bill_depth_mm", color="species"))
                + p9.geom_point()
            )

    with ui.card():
        ui.card_header("Measurements")
        @render.data_frame
        def table():
            return qc.df()

ui.page_opts(fillable=True)

library(shiny)
library(bslib)
library(querychat)
library(DT)
library(ggplot2)
library(palmerpenguins)

qc <- QueryChat$new(
  penguins,
  client = "lmstudio/google/gemma-4-26b-a4b",
  tools = c("filter", "query", "visualize")
)

ui <- page_sidebar(
  sidebar = qc$sidebar(),
  layout_columns(
    fill = FALSE,
    value_box("Penguins", textOutput("count"), showcase = bsicons::bs_icon("binoculars")),
    value_box("Species", textOutput("species"), showcase = bsicons::bs_icon("fingerprint")),
    value_box("Avg Body Mass", textOutput("avg_mass"), showcase = bsicons::bs_icon("speedometer"))
  ),
  layout_columns(
    card(card_header("Bill Dimensions"), plotOutput("scatter")),
    card(card_header("Measurements"), DTOutput("table"))
  )
)

server <- function(input, output, session) {
  qc_vals <- qc$server()
  df <- qc_vals$df
  output$count <- renderText(nrow(df()))
  output$species <- renderText(length(unique(df()$species)))
  output$avg_mass <- renderText(paste0(round(mean(df()$body_mass_g, na.rm = TRUE)), "g"))
  output$scatter <- renderPlot({
    ggplot(df(), aes(bill_length_mm, bill_depth_mm, color = species)) +
      geom_point()
  })
  output$table <- renderDT(df())
}

shinyApp(ui, server)

Custom tools

querychat comes with three built-in tools, but you can also easily add your own custom tools. This is possible thanks to the extensible foundation provided by chatlas (ellmer). These packages also make it quite easy to implement tools – all you really need is a Python / R function that performs some operation. You can also fully customize the display shown, thanks to their rich support for tool call displays (R).

To give you a sense of what other capabilities are possible, you could start out as simple as querying real-time weather information, but also get as sophisticated as a RAG-like knowledge retrieval agent. For example, here’s how you’d let users ask whether weather conditions might relate to trends in your data:

import requests
from querychat.express import QueryChat
from chatlas import ChatLMStudio
from palmerpenguins import load_penguins

chat_client = ChatLMStudio(model="lmstudio/google/gemma-4-26b-a4b")

def get_current_weather(lat: float, lng: float):
    """Get the current weather for a location."""
    lat_lng = f"latitude={lat}&longitude={lng}"
    url = f"https://api.open-meteo.com/v1/forecast?{lat_lng}&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
    response = requests.get(url)
    return response.json()["current"]

chat_client.register_tool(get_current_weather)

qc = QueryChat(
    load_penguins(),
    "penguins",
    client=chat_client
)

library(querychat)
library(ellmer)

chat_client <- chat_lmstudio(model = "lmstudio/google/gemma-4-26b-a4b")

get_current_weather <- function(lat, lng) {
  lat_lng <- paste0("latitude=", lat, "&longitude=", lng)
  url <- paste0("https://api.open-meteo.com/v1/forecast?", lat_lng, "&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m")
  response <- httr::GET(url)
  httr::content(response)$current
}

chat_client$register_tool(
  tool(
    get_current_weather,
    "Get the current weather for a location",
    lat = type_number("Latitude"),
    lng = type_number("Longitude")
  )
)

qc <- QueryChat$new(
  palmerpenguins::penguins,
  client = chat_client
)

Underneath the hood, querychat’s built-in tools use this same foundation. The “magic” of these tools really breaks down to three key insights:

1. LLMs are very good at translating natural language into code.
2. Tool call arguments can be executable code (like SQL or ggsql) rather than just simple values.
3. Tool calls can manage reactive state in a Shiny app — for querychat, that state is the current filter query, but the same pattern could control input controls, tab selection, or other UI state.

What’s next?

This release is just the beginning of our vision for (responsibly) exploring data via natural language. We’re excited to see what you build with it, and we’re already thinking about the next set of features to add. Some things on our near-term roadmap:

• Multiple tables.
• Reproducible takeaway artifacts, like Quarto dashboards
• Support for more semantic layer solutions beyond Snowflake, so more users can give the LLM authoritative definitions of their business logic.

Learn more

• querychat documentation (R) — full guides on data sources, context, tools, and deployment
• ggsql — the grammar of graphics for SQL that powers querychat’s visualizations
• chatlas (ellmer) — the underlying LLM tool-calling libraries, useful for building custom tools
• shinychat (R) — the chat UI component that querychat builds on
• Shiny (R) — the web framework powering querychat apps
• Source on GitHub — issues, discussions, and contributions welcome

If you are preparing for your next talk (whether at SciPy or another conference), you might be looking for the most effective way to showcase code and its output in your deck. And, if we do say so ourselves, Quarto is the premier tool for creating polished presentations that shine in scientific contexts.

Why? Because Quarto was designed just for this purpose! As an open-source scientific and technical publishing system, Quarto allows you to craft dynamic content that weaves your narrative together with Markdown and Python code, and then renders them into a single file that elegantly showcases your results. By using a single source file, you don’t have to manually copy and paste code or its outputs. Any changes you make are reflected in the latest version by rerendering the document.

Hopefully, this has piqued your interest! Curious how it looks? We built the deck below in Quarto; keep reading to learn how.

Get started with slides in Quarto

Install Quarto

We recommend using Positron as your editor, since Quarto is preinstalled. If you are using VS Code, install the Quarto CLI and the Quarto VS Code Extension.

Create a new document

Open a new folder, enter the Command Palette (Cmd+Shift+P) and search for Quarto: New Quarto document (qmd). Save the file as index.qmd.

Change the format to revealjs

Your new document will include a YAML header for managing your document’s metadata. You’ll see that the default is set to HTML via format: html:

---
title: "Untitled"
format: html
---

However, Quarto is incredibly versatile, and it can render your work into PDFs, Word documents, and much more! We recommend the reveal.js format for creating aesthetically pleasing code-centric slides. reveal.js also provides a variety of useful features tailored for displaying scientific results and technical workflows.

You can switch your document from HTML to reveal.js by updating the format in your YAML header to format: revealjs:

---
title: "Untitled"
format: revealjs
---

Click the Preview button () at the top left of your editor to see what your presentation looks like!

You can also preview from the command line:

quarto preview index.qmd

Build the slides

From here, we can move on to the fun part: building our slides!

Edit metadata

As alluded to earlier, we edit the metadata document by modifying the YAML header. You can change the title, add yourself as an author, and add your presentation date:

---
title: "Make your SciPy presentation in Quarto"
author:
  - Isabella Velásquez
  - Charlotte Wickham
date: 2026-07-14
format: revealjs
---

Those values then set up your title slide.

Add your first slide

Below the YAML header is where you write your slides. Quarto uses Markdown, a text formatting language, for text:

---
title: "Make your SciPy presentation in Quarto"
author:
  - Isabella Velásquez
  - Charlotte Wickham
date: 2026-07-14
format: revealjs
---

Slides are just Markdown and code:

- Write your narrative in **Markdown**
- Weave in **Python** code and its output
- Render it all to one reproducible file

You can control aspects of your presentation by nesting options under revealjs in the YAML header. For example, you can make any list display incrementally by adding incremental: true:

---
title: "Make your SciPy presentation in Quarto"
author:
  - Isabella Velásquez
  - Charlotte Wickham
date: 2026-07-14
format:
  revealjs:
    incremental: true
---

Now as you advance the slides, the bullets appear one at a time.

Add a new slide

To add a new slide, add a new heading. A Level 1 heading adds a new section, while a Level 2 heading adds a new slide.

# Features for showing code

## Add Python code cells

Continue adding new slides until you’re done!

Add Python code cells

To add Python code to your slide, put it within a code cell, which is delineated by three backticks ``` and python within curly braces. By default, Quarto reveal.js presentations do not show your code cells, because they assume you are presenting just your output. If you do want to show your code, you can add a cell option, designated by a special comment, #|, followed by the option using YAML syntax. In this case, echo: true lets Quarto know to show the code.

## Add Python code cells

```{python}
#| echo: true
from plotnine import *
from plotnine.data import anscombe_quartet
```

Code output is included

When you render, Quarto runs the code cells and includes their output right below the code:

## Code output is included

```{python}
#| echo: true
anscombe_quartet.head()
```

Show code without running it

Some code only makes sense to run live — like %view, which opens your data in Positron’s Data Explorer. To show such code without running it, add the eval: false cell option, which tells Quarto to show the cell but not evaluate it:

## You can show code without running it

```{python}
#| echo: true
#| eval: false
%view anscombe_quartet
```

Add a theme

The Quarto default look is great, but say you want to add your own theming. You can do that in a single YAML file using brand.yml.

In your root directory, create a file called _brand.yml. Add specifications as listed on the brand.yml documentation site. You can edit the font, colors, and more (add as much or as little as you’d like). Next time you render your slides, the brand will be automatically picked up!

If you’d like a _brand.yml file to get you started, here is one that mimics the SciPy conference style. Put it in the root directory of your presentation, and it will look like this:

Features for showcasing Python code

You may be thinking, this is great, but I can make slides in any old software! True, but Quarto has specific features that really elevate your audience’s experience.

Code line highlighting

Sure, you can show a block of code on your slide. But you’re usually talking about a specific line or lines of code at a time. If you want to draw your audience’s attention to a specific section of your code, you can use code line highlighting.

For example, if you want to first highlight line 2, then lines 3 through 4, then line 5, you can add the code-line-numbers cell option:

```{python}
#| echo: true
#| code-line-numbers: "2|3-4|5"
(
    anscombe_quartet
    .groupby("dataset")[["x", "y"]]
    .apply(lambda g: g["x"].corr(g["y"]))
    .round(2).to_frame("correlation")
)
```

Scroll through to see what it looks like:

Show code output in a new slide

When rendered, the slides will automatically resize based on the content. However, this means if you have a lot of code and a large output (like an image), it will be hard to see both in a single slide.

Luckily, the Quarto developers have thought of this and have the output-location cell option where you designate where the output should show up. For example, to show the output on the new slide, set output-location to slide:

```{python}
#| echo: true
#| output-location: slide
(
    ggplot(anscombe_quartet, aes("x", "y"))
    + geom_point(color="sienna", fill="orange", size=3)
    + geom_smooth(method="lm", se=False, fullrange=True,
                  color="steelblue", size=1)
    + facet_wrap("dataset")
    + labs(title="Anscombe’s Quartet")
    + scale_y_continuous(breaks=(4, 8, 12))
    + coord_fixed(xlim=(3, 22), ylim=(2, 14))
    + theme_tufte(base_family="Futura", base_size=16)
    + theme(
        axis_line=element_line(color="#4d4d4d"),
        axis_ticks_major=element_line(color="#00000000"),
        axis_title=element_blank(),
        panel_spacing=0.09,
    )
)
```

Add a filename and extension

A subtle (but very helpful) feature of Quarto is the ability to specify the filename and extension of a code block, which you can use if you are talking about different files or programming languages and want to visually distinguish them. Add filename= to your code block:

```{.bash filename="Terminal"}
pip install pandas
```

<br>

```{.python filename="script.py"}
import pandas as pd
```

Extensions for scientific presentation

So far, we’ve just mentioned features that are built into Quarto; however, one of the most powerful features of Quarto is its extension system. Both the Posit developers and the community have built an incredible ecosystem of extensions that augment what Quarto can do. There are hundreds of extensions (see the Quarto gallery by Mickaël Canouil), but here are a curated few.

QuartoLive extension for interactive Python code blocks

You no longer have to switch between your slides and your IDE to run code! Using QuartoLive, you can embed interactive Python code blocks. Run the code, edit it, and rerun, all within your Quarto reveal.js presentation.

Provide a direct link to your slides

Usually, the first question asked during a presentation is, “Will the slides be provided?” Evade that question by using the QR code extension, which adds a QR code that the audience can easily scan while they watch so they can find the slides after the presentation is over.

Add accessibility features

For your audience to be able to read the text on your slides, the font size should probably be larger than you anticipate.

The reveal.js A11y extension provides accessibility features for your slide deck. One nifty feature is the ability to increase the font size on the fly. Enter the menu by pressing A, and then zoom in to what you need.

Publish and share your slides

After you’ve done the fun work of creating your slides, you’ll want to publish and share them with others. We recommend Posit Connect Cloud, which has a generous free tier for Quarto documents, Streamlit and Shiny apps, and much more.

If you’re working in Positron, the Posit Publisher extension is built in and gives you push-button deployment to Posit Connect Cloud right from your editor (in VS Code, grab it from the Marketplace).

If not, you can also publish from the command line with quarto publish, which renders your slides and uploads them:

quarto publish posit-connect-cloud index.qmd

The slides for this very post are published at posit-devrel-make-your-scipy-presentation-in-quarto.share.connect.posit.cloud.

Press F to enter full screen, and you’re ready to present!

Welcome to the wonderful world of Quarto slidecrafting

We hope that this post inspired you to give Quarto presentations a try!

We’ve only scratched the surface — the Quarto reveal.js documentation covers the full set of features for building presentations.

If you are completely new to Quarto, Charlotte’s YouTube video is a great introduction to setting it up, creating a document from scratch, and rendering it.

If you want to see what else is possible, Emil Hvitfeldt is working on a book called Slidecrafting on creating functional and beautiful Quarto reveal.js presentations through theming, layout, interactivity, and extensions.

And definitely look through Mickaël’s Quarto extension gallery to see if other extensions are useful to you. His blog post, Quarto Reveal.js Extensions to Sharpen Your Slides, also has more advanced tricks you can apply to your scientific and technical publications.

Do let us know what you end up creating!

But Posit Assistant was not our first agent, and it’s not likely to be our last. The proliferation of agents coming from Posit has started causing serious confusion. This post hopes to clear that up by providing a chronology of the agents we’ve created, our rationale for their design and architecture, and what you need to know about them today (if anything).

TL;DR

Posit Assistant is our newest, most powerful agent for data science. It builds on what we learned from creating our previous agents: Positron Assistant and Databot.

Positron Assistant

• Strengths: Time to market; connects to a variety of providers; tight IDE integration
• Weaknesses: Legacy agent architecture; not available in RStudio IDE
• Status: Succeeded by Posit Assistant (as of June 2026)

This was the first “off the shelf” data science agent we ever shipped, and is available exclusively in Positron. It was forked from GitHub Copilot, and like Copilot, you can ask it general coding questions, have it write code, and have it explain existing code to you.

While the Positron Assistant experience is largely the same as Copilot, there are two major differences. The first is that it can access Positron-specific features like running code in an interactive R or Python session, inspecting variables, and generating/inspecting plots. These features make it much more useful for data work.

The second major difference is the ability to connect to other LLM providers than the Copilot service, right out of the box. At this time, Positron Assistant can connect to Anthropic and OpenAI (with API key), AWS Bedrock, Snowflake Cortex, GitHub Copilot, Microsoft Foundry, Google Gemini, Posit AI, and even custom (OpenAI-compatible) providers. When running in a properly configured Posit Workbench installation, these can often be seamlessly authenticated.

GitHub Copilot is tightly integrated with VS Code, and Positron Assistant is similarly well integrated with Positron. You can start an “inline chat” right at your editor cursor and ask Positron Assistant to fix or explain errors with one click. These were major benefits to starting with GitHub Copilot as a base.

Unfortunately, there are serious downsides to the GitHub Copilot heritage as well. The architecture and core APIs of Copilot were designed to be extended in ways that didn’t end up being very popular, while tool calling felt grafted on and cache control nonexistent. The net effect was a lot of abstraction and complexity between the user prompt and what actually went into the LLM request, making it difficult for us to get the best performance out of the LLM. And users noticed this, saying that Positron Assistant was generally effective but also duller than other agents, including Databot and Claude Code, even when using the same underlying model.

Another big downside to GitHub Copilot was that its chat UI was more austere and harder to customize than what we could do on our own. Any changes we made were asking for technical debt, multiplied by the incredibly fast pace of upstream changes that we need to regularly merge.

Overall, the Positron Assistant project gave us what we needed at the time: a competitive, full-featured, IDE-integrated, agentic coding assistant. But for data work, we felt like we knew how to do better in a number of ways, including agent performance and UI/UX.

Databot

• Strengths: Effective agent harness; well tailored to exploration tasks
• Weaknesses: Not general purpose enough; not available in RStudio IDE
• Status: Succeeded by Posit Assistant (as of June 2026)

Databot was conceived in December 2024, in response to a specific question: what would happen if we took a frontier model (Claude 3.5 Sonnet), seeded it with simple instructions, and gave it unfettered access to the most powerful tool we could think of (a live R or Python session)?

At the time, it seemed hopelessly reckless to give so much power to an LLM, and we ran the first prototype with real trepidation! Fortunately, this approach is more effective and significantly less dangerous in practice than in theory. In a world before Claude Code, Databot felt like absolute magic. That magic was compounded by three decisions we made in an effort to make Databot excellent for exploratory data analysis (EDA):

1. The ability not only to execute code but to see the results (including tables and plots)
2. Keeping the human in the feedback loop by only allowing so many tool calls before stopping to summarize progress and check in with the user
3. Always providing three to five suggestions of what to do next

With a suitably capable LLM, this combination makes data exploration feel like flying.

It took us months to convince ourselves that a tool like this was safe enough to ship to users, and months more to turn the prototype into production-ready software. Since this felt like such an aggressive architecture, we constrained Databot to a narrow remit: it was only for interactively exploring data. After exploration was complete, it could also export a reproducible Quarto report that records both the findings and the methods, but that was pretty much it.

We officially launched Databot on August 28, 2025 with this blog post. We were still so nervous about the dangers that we published a companion blog post at the same time, telling users how not to use Databot. As models have gotten better, and tens of millions of users have grown accustomed to aggressively agentic AI tools, this second blog post remains technically accurate but perhaps reads a bit alarmist. In practice, agentic AI coding tools are not completely safe, but neither are they necessarily as dangerous as they may theoretically appear. Their usefulness across a wide variety of tasks helps balance this risk.

Databot’s crucial weakness turned out not to be that it was too dangerous, but too narrowly scoped. EDA does not happen in a vacuum. It’s often done in service of some larger project, and insights derived from EDA typically immediately lead to the creation of a reproducible cleaning script, interactive Shiny app, automated data transformation job, etc. As an EDA-focused agent harness, Databot did not have the tools needed to do those tasks well.

This constrained nature left users feeling frustrated. Databot could be so intelligent, so facile with data exploration, yet so suddenly clumsy the moment you asked it to edit a data cleaning script, and the distinction felt arbitrary. Even if you understood Databot’s limitations, it still left you needing to manually perform a “hand off” between an EDA session in Databot and a Shiny app authoring session in Positron Assistant.

Why did we make two agents instead of one?

Given the obvious downsides of creating two distinct agents for Positron instead of focusing on one — confusion, disjointed experience, duplication of effort — why did we do it?

First, as stated above, Databot felt not just risky but borderline reckless in how much power we were encouraging the agent to wield. Positron Assistant had very similar behavior to Copilot, so while not totally “safe”, it felt like a widely understood and accepted set of tradeoffs. It felt reasonable to have one conservative agent that we could tell everyone to use in Positron Assistant, and one aggressive agent for early adopters to play with in Databot.

Second, Positron Assistant seemed easier to build because we could start with so much existing functionality from Copilot. For Databot, we had to build everything from scratch: the agent harness, the chat UI, loading and saving past conversations, everything, and it was hard to know in the beginning how fast we could do it and how successful we would be. Again, it felt right to have one agent that we knew we could ship quickly, and one that might take longer but would potentially give us a better long-term platform.

These reasons made sense to us in early 2025, but they haven’t stood the test of time. As Databot gestated, Claude Code showed the world that powerful AI agents had a usefulness-to-risk ratio that far, far exceeded most people’s thresholds. And forking Copilot didn’t give us nearly the boost in development speed we expected: while it did give Positron Assistant a huge head start, it also saddled Positron Assistant with many unnecessarily complex abstractions and introduced us to the very expensive recurring task of merging the torrent of upstream Copilot changes with our extensive modifications.

A final reason had to do not with risk but with specialization: Databot’s WEAR loop felt distinct from Positron Assistant’s generic loop, and this felt like a pretty fundamental UX difference. Once we got serious about combining the two, it turned out not to be so fundamental after all, and for the most part we feel like our next agent succeeds at “code-switching” as needed.

Posit Assistant

• Strengths: Effective agent harness; great for EDA, coding, and general-purpose agent tasks; integrated into both Positron and RStudio
• Weaknesses: Not designed for highly autonomous or highly parallel agentic work (if that’s what you’re into)
• Status: Now available in RStudio, in preview in Positron

Posit Assistant is our newest data science agent, designed to build on what we liked most about each of the AI agents we’ve built and used in the past:

• A simple agent harness with a small number of powerful and general tools
• Prompting, tools, and UI/UX designed for the needs of data scientists
• Full access to live R/Python sessions, including variables and plots
• Integrated into our data science IDEs
• A codebase designed for fast iteration
• Extension points based on MCP and skills

Crucially, we built Posit Assistant to live in both RStudio (since April 2026) and Positron (since June 2026). Not only did this finally bring an integrated agent to RStudio, where most R users still live today, but it also meant that every ounce of effort we put into improving Posit Assistant helps both RStudio and Positron users.

While Positron Assistant (the older one) grew out of Copilot, Posit Assistant (the new one) grew out of Databot. There was much we liked about Databot, and it didn’t take much effort to expand its mission from the narrow task of exploratory data analysis to being a great general-purpose agent.

The big advantage of Positron Assistant in early 2025 turned out to be a big disadvantage by early 2026: being built on GitHub Copilot. While Copilot was arguably one of the two or three best coding agents for most of its existence, by the end of 2025 it was thoroughly outmatched by Claude Code.

At the risk of oversimplifying, the Copilot approach thinks the user should play a major role in deciding what context the underlying LLM gets to see. For example, Copilot and Positron Assistant have UI features that let you specify what files from your project you want to include with your next user prompt. You can also use @-mentions to bring in reference materials (for example, the Shiny VS Code extension lets you mention @shiny to bring in the Shiny docs).

In contrast, Claude Code’s approach is to give an LLM access to powerful general-purpose abilities, like reading/writing/editing files and executing arbitrary bash commands, and then trusting the LLM to use them to gather the information it needs. This approach worked well when Claude Code was released in February 2025, and then dramatically improved over the course of 2025. The overall effect was that Claude Code felt significantly smarter and more engaged, even when using the same underlying language model.

The highest compliment I can give to Posit Assistant is this: when exploring data, it feels a lot like Databot, and when coding, it feels a lot like Claude Code. And where Claude Code is a general-purpose coding agent, Posit Assistant is built specifically for people who work with data, with modes and skills for data tasks like data cleaning, Shiny app creation, and predictive modeling.

Why did we call it “Posit Assistant” when we already had “Positron Assistant”!?

Maybe the most controversial thing about Posit Assistant is its name: Posit Assistant. First, it’s quite dull. Second, why isn’t it “Posit Agent”? Third, why would you give it almost-but-not-exactly the same name as the thing it’s superseding?

These are all decisions that were made by me, Joe Cheng, and if you think they are bad decisions, then just know the Posit Assistant team agrees with you. (I stand by the name, but only just!)

On dullness: A natively integrated AI chatbot for an IDE is table stakes, not a distinguishing feature. While we need a name today, I want users to eventually think of Posit Assistant as “RStudio’s chat pane” or “Positron’s built-in AI”, that is, for its identity to be subsumed into the host IDE. We believe most data practitioners will continue to use IDEs even as these models get more capable, and that the “I” in IDE is where we can offer real value. Instead of trying to build a new, distinct brand, I wanted there to barely be a brand at all.

On “Agent”: The term “agent” is heavily overloaded these days. In the sense that it’s been used so far in this article, it means “models using tools in a loop,” and Posit Assistant definitely fits that definition. But a lot of our customers understand the word to refer to “models working highly autonomously for long periods of time”, and we really wanted to avoid this connotation. Posit Assistant does have the ability to work autonomously if necessary and appropriate, but much of our harness encourages the model not to work autonomously in situations where it otherwise would.

On Positron Assistant/Posit Assistant: This one is truly confusing, and the hardest one to defend. My defense is that the confusion is temporary. For most of Positron Assistant’s short history, Posit Assistant didn’t exist. For most of Posit Assistant’s history, Positron Assistant will no longer exist. We’re in a moment right now where we’re mid-transition, so it’s very confusing, but hopefully, that confusion is temporary.

I hope you will find this explanation to be satisfactory, and if not, at least now you know who to blame!

One of the least fun aspects, though, is that you never have time to do most (or even half) of the great ideas that bubble up through the community. RStudio’s issue tracker is full of worthy requests that have been unimplemented for years, often because they would require outsized changes to the core system’s architecture or behavior.

When we set out to make Positron, RStudio’s issue tracker became a gold mine of possibilities. Because Positron has a new architecture and is built on a different platform, many of the things that we’d never been able to do in RStudio suddenly became possible.

Today, we take a look at 10 of the most upvoted RStudio feature requests of all time and how those features have been incorporated into Positron. Every one of these 10 requests is on the front page of the most-upvoted RStudio issues as of this writing.

#1: Fully configurable pane layouts

Most IDEs have a somewhat more flexible system which allows for arbitrary tab arrangement, often using mouse gestures to edit configuration on the fly.

– #2879

This has been one of RStudio’s most-upvoted requests for years. In Positron, this feature is largely inherited from upstream Code OSS (the open source core of VS Code). It has a very flexible layout system which allows tabs to be rearranged, split, hidden, and more with natural dragging and mouse gestures, or via context menus. Try right-clicking on any tab or divider to show places you can move it:

Read more about it here:

VS Code Layout Configuration

Positron also ships with a variety of layout presets customized for specific tasks. Try the View: Stacked Layout command to make it look more like RStudio, or View: Notebook Layout to focus on a Quarto document or Jupyter Notebook.

#2: Fixed size graphics device

It would be excellent if one could set the RStudio graphics device to generate plots as they would be generated by a non-interactive device with fixed dimensions, so that one could do iterative plot-making within the IDE rather than call png(), look at the outputs in another program, and then fiddle with font scaling, etc. and repeat.

– #4422

RStudio always draws plots to fit the exact dimensions of its Plots pane, which can make it difficult to iterate on a plot you’re preparing for publication.

When we added a Plots pane to Positron, we included a new tool that lets you indicate the dimensions at which you’d like the plot to draw. You can have it fit to some common aspect ratios or – as in the RStudio feature request – specify the exact size at which you’d like the plot to be drawn.

Positron’s Plots pane also features a visual history browser, and it remembers the code used to create the plot so you can jump to it or re-run it.

#3: Multi-line statement support for Python code

It would be really great to have RStudio support of multi-line statements extended to Python code as well.

– #9014

One of RStudio’s key R features is multi-line statement detection. When you tell RStudio to execute R code at your cursor location, it doesn’t just send the current line of code; it gathers all the lines that are part of the statement and sends them together. RStudio doesn’t know how to do this for Python, however.

In Positron, Python and R are peers, and we’ve implemented multi-line statement detection for Python, too. Placing your cursor anywhere in a Python statement and invoking Run will execute the whole statement.

#4: Tree view for browsing files and directories

Hi, is there any plan for browsing files and directories in tree view mode?

– #2552

RStudio’s file browser lists only one directory at a time. Positron inherits Code OSS’s tree-based explorer, which not only shows files and directories in context but even has customizeable icons!

#5: View different parts of a source file at the same time

In TexShop there’s an option to split source which allows you to see (and edit) multiple areas in a document in one window so that you don’t need to keep scrolling up and down. It would be wonderful to have this as a functionality in the RStudio IDE editor

– #2129

In Positron, you can have several editors open at once against the same file. With a file open, try using the Split Right or Split Down commands, which will create a second tab for the file that can be scrolled independently. You can access this via the Command Palette, or via the editor action toolbar:

#6: Add builds for Windows on ARM

RStudio is built for Windows only for Intel (x86) processors. However, there is now a version of Windows 11 available for ARM based processors.

– #11977

Microsoft has taken a page from Apple’s playbook and started producing its own ARM-based hardware, such as the ARM-based Surface devices, and ARM-based Windows PCs are also now available from third-party manufacturers.

When we built Positron, we designed its native components to be easy to recompile against different CPU architectures. On Windows, Positron includes both x64 and arm64 R computation engines (kernels), so it can run natively with both x64 and arm64 versions of R. Its Python support, likewise, works great on ARM-based PCs.

#7: Persistent Julia engine

It would be useful if we can use Julia in RStudio seamlessly as well as Python.

– #1798

One of the main architectural goals of Positron was to make it adaptable to any language. It is a data science platform that supports “language extensions”. Positron’s Python and R support subsystems are included in your Positron download, but are implemented as extensions.

While Posit doesn’t currently have the expertise to develop well-rounded support for Julia, that hasn’t stopped the community from creating a Positron extension that you can install to add Julia support. When installed, Julia becomes a peer of R and Python in Positron, and connects to Positron’s Console, Variables, History, Packages, and Plots panes.

Find it here: Julia for Positron

One of the questions we get a lot is why Positron itself isn’t a VS Code extension. This is one of the reasons why: Positron isn’t an extension; it has extensions.

#8: Teaching/presentation mode

Quite a lot of people use RStudio hooked up to a projector to teach others. It would be great if those people had a key combo that could toggle between their current theme settings and some good defaults suitable for teaching/demos. … Perhaps the ultimate goal would be to have the teaching mode itself configurable.

– #4276

In Positron, it is possible to define different “profiles” that have different themes, font sizes, and other settings, and switch between them from the Command Palette, so it is possible set up a “Presentation” profile with a high-contrast theme and large text.

Profiles go beyond just layouts and themes. More documentation here:

https://code.visualstudio.com/docs/configure/profiles

#9: Fix columns or rows when scrolling data

The data viewer is one of the most used tool of data analysis in RStudio. However, a very useful feature is missing. In horizontal scrolling a big table with lots of column (it’s very common to have more columns than one screen can fit), it will be very helpful to fix the row name column so that it’s always visible(i.e. always keep it within screen with scrolling). … More generally, sometimes we also want to fix certain columns so that it remains visible when scrolled horizontally. The row name column is just a special case of this request.

– #3463

It’s pretty common to have a column of data that represents a key value or name for the observation, or a value to which you wish to compare other values. In Positron, you can pin any column to fix it to the left, so that it is always visible as you scroll the other columns horizontally. Click on the column’s action menu (vertical ellipsis) and choose Pin Column.

You can also pin rows! Right-click on the row and choose Pin Row.

#10: Remove all objects in the Python environment

Normally, we can do it easily in R environment by just 1 click but Python doesn’t support it.

– #8750

It’s supported in Positron! With a Python session open in the Console, you can use the trash icon to clear all the objects from the session – in one click.

… And a lot more.

Some of our other favorite Positron-only features that don’t have a top-upvoted RStudio issue attached:

• Multiple R sessions: RStudio runs only one primary R session at a time; any concurrent work needs to be done in a non-interactive background job. Positron supports multiple concurrent interactive R sessions.
• Multiple R versions: RStudio can only work with one R version at a time, and you need to switch externally using a tool like rig. Positron will let you choose from any R installation on your system and can even associate specific R versions with specific projects.
• Crash recovery: RStudio crashes when R does, but in Positron all you’ll lose is the R session itself, which just gets safely restarted.
• Remote sessions: Connect remotely to another computer over SSH and run R sessions inside it, or work with reproducible projects inside devcontainers.

See Comparing RStudio and Positron Features for more.

What about RStudio?

While Positron’s design has made it more practical to make many of these advancements, the point of this post isn’t that you should switch to Positron if you’re happy in RStudio. In fact, features are also flowing in the other direction; many of Positron’s features are making their way back into RStudio. For example, the latest release of RStudio has:

• a redesigned data viewer inspired by Positron’s data viewer;
• code formatting optionally powered by air, Positron’s R formatter;
• warning/error styling in the R console inspired by Positron’s Console; and, of course
• Posit Assistant, a platform-agnostic data analysis assistant that works in both IDEs.

If you use RStudio and are interested in trying Positron, a good place to start is our Migrating from RStudio guide.

Thank you for the creativity, ideas, and support you’ve shown our IDEs over the years. Keep it coming!

1. Posit Assistant has out-of-the-box access to your R or Python session.
2. Posit Assistant can display plots in the chat, leading to easier interpretation for you and the agent.
3. Posit Assistant has specialized interaction modes, skills, and prompting for data analysis.

You can also see a full demo of these features in this video:

Coding agents vs. chat apps

Claude Code and Posit Assistant are both coding agents. An agent is a “model running tools in a loop,” meaning an agent can see your environment, take actions in that environment (e.g., run code), and iterate based on the outcome of those actions. These abilities make agents vastly more useful for coding than chat apps like ChatGPT.

Chat apps can’t see your environment or take any actions in your environment. You have to copy-and-paste code into your session, run it yourself, and paste any errors or output back. This both makes the experience more frustrating and increases the probability of errors, because the model is writing code that operates on data and files that it doesn’t actually have access to.

If you haven’t tried a coding agent before and are still relying on chat apps for coding assistance, we recommend trying one out.

Built-in access to your R/Python session

The first major difference is that Posit Assistant has built-in access to your R or Python session. This means that Posit Assistant, without any additional configuration, can see your R or Python objects and run code directly in your active session.

Claude Code lacks this ability out of the box. It can write R code to files and run scripts, but it can’t directly access data you’ve loaded or run R code interactively.

If you ask a coding agent without session access to, for example, filter a tibble df you have in your environment, it will write R code to a script and then run that script with the Rscript command. This works, but has a couple of downsides:

1. Before running the script, the agent can’t actually tell that df exists. If it doesn’t exist, it will have to wait for an error message from the script.
2. You might not want to create and run scripts for every bit of code.
3. It leaves you and the agent on different footing: you have direct access to your session, but the agent doesn’t. This can make errors more likely and the general experience more frustrating.

It is possible to give agents like Claude Code access to your R or Python session by using an MCP server. In the walkthrough video, we show how to do this using the btw package, giving Claude Code the ability to access our R session and run R code directly.

Even with an MCP server, however, it may be difficult to see the code being run on your behalf. For some tasks, this might not matter, but if you’re analyzing data it can be important to understand the analysis in detail. For data analysis tasks, Posit Assistant is designed for auditability and transparency. The code is visible in the tool call UI with syntax highlighting and styling, so you can easily audit what’s happening to your data at each step.

See this comparison in the video: Claude Code | Posit Assistant

Data visualization

Claude Code can write code to create plots, but can’t display them natively in the terminal and will need an alternative way to show them to you (e.g., opening a file in Preview). Even for the model itself to see the plot, it has to save the plot to a PNG file and then read that file.

Because Posit Assistant runs code in your console, plots show up in the RStudio or Positron plot pane, as well as directly in the chat panel. This makes it easier for you to quickly inspect and analyze the plot and iterate if needed. Posit Assistant will also automatically see the plot image and typically interpret it or assess whether it is correct, which makes it very useful for EDA and data analysis.

This ability for you and the agent to both see the same plot is important for auditability. There’s evidence that even the most advanced models sometimes misinterpret plots that contradict their expectations, and so having you and the agent looking at and interpreting the same plot makes it easier to catch mistakes.

See this comparison in the video: Claude Code | Posit Assistant

Specialized data analysis capabilities

Session access and plotting affordances both directly support data analysis, but Posit Assistant also has interaction modes, prompting, and skills specifically designed for it.

Posit Assistant is both a general-purpose coding agent and a specialized data analysis agent, and it behaves slightly differently depending on your task. During data exploration, it only runs a few bits of code at a time, then summarizes what it found and suggests next steps. Because the purpose of data analysis, especially exploration, is for you to learn about the data, the entire process breaks down if the model runs ahead with analysis you can’t keep up with. Posit Assistant’s approach to co-analysis with the user is designed to support your understanding of the data rather than hinder it.

Claude Code excels at writing code, but is generally oriented toward writing that code to files, executing it, and reviewing it, rather than exploring data step-by-step with the user.

Posit Assistant also has specialized prompting, skills, and tools that promote sound data analysis. These include skills for making Shiny apps and Quarto reports, a data cleaning mode, and prompting about rigorous statistical and modeling practices.

See this comparison in the video: Claude Code | Posit Assistant

Posit Assistant is designed for data work

Claude Code, Codex, and other coding agents are very useful tools. They excel at general-purpose coding tasks, and you might want to use them for work that benefits from running multiple agents in parallel, or because you want to take advantage of your existing subscription plans.

However, we made Posit Assistant because we think the millions of data scientists, researchers, and analysts who rely on R and Python should have an excellent agent specifically designed for them and their needs. Those needs include data analysis and visualization, but also package development, Shiny app creation, and other coding-focused tasks in the data science ecosystem.

Learn more about Posit Assistant: https://posit-dev.github.io/assistant/.

Welcome back to another edition of our monthly Positron updates! Each month we share highlights from our latest release and useful resources.

Posit Assistant

Last release we introduced Posit Assistant, our unified, data-science-focused approach to AI assistance. This release continues that work, and we want to give you advance notice that the older Positron Assistant will be deprecated in the next release. If you are still using Positron Assistant, we encourage you to migrate to Posit Assistant now.

Posit Assistant supports the same broad set of providers as Positron Assistant, along with the Posit AI model provider and new experimental support for Google Vertex. Learn more about the differences between the new Posit Assistant and the older Positron Assistant:

You may also be interested in comparing Posit Assistant and Claude Code.

New in Posit Assistant this release, you can use the Posit AI model provider for Next Edit Suggestions, which propose your likely next change as you edit. You can also access the Configure Language Model Providers item in the accounts menu. You can ask a question, report a bug, or request a new feature for Posit Assistant separately from Positron now, but don’t worry too much about where to send your feedback; we will help route it to the right place!

Packages pane improvements

We introduced the Packages pane last release, and this release makes it more informative and flexible. A Show Help button and context menu entry on every package take you straight to its documentation in the Help pane. You can now combine category filters as an intersection, so you can narrow the list to, for example, packages that are both attached and outdated. A new Item Size toggle lets you switch between a compact row view and a richer card view that surfaces package descriptions and other metadata.

For R users, the new packages.r.installer setting controls whether installs, updates, and removals use pak, base R, or an automatic choice. The setting that controls the pane has been renamed to packages.enabled; the previous positron.packages.enable setting is deprecated but still honored.

Inline output for Quarto

Inline output for .qmd documents was one of Positron’s most-requested features ever, and it is now out of preview. A new toolbar button in Quarto documents gives you one-click access to running cells, managing inline output, and showing the console.

Inserting code into a Quarto document from the History pane now automatically wraps it in cell markup when you drop it into a prose region. You can opt into inline output with the positron.quarto.inlineOutput.enabled setting.

Faster startup

We continue to invest in performance improvements, and Positron starts up even faster in this release. Positron now caches previously discovered system interpreters, dramatically speeding up startup in new folders and projects; you can control this with the new interpreters.discoveryCache.enabled setting. On Windows, we fixed multi-minute startup delays by skipping slow PATH discovery by default, governed by the new positron.r.interpreters.pathDiscoveryMode setting. We also fixed an occasional hang at “Preparing” when starting Positron after updating to a new version.

A more customizable interface

This release gives you finer control over Positron’s chrome so you can tailor the interface to your workflow. Several layout settings that previously weren’t always honored now work as expected:

• workbench.topActionBar.visible reliably hides and shows the top action bar at runtime
• workbench.secondarySideBar.defaultVisibility is respected when you set it explicitly
• workbench.secondarySideBar.showLabel lets Secondary Side Bar items render as compact icons

You can also enable window.commandCenter to bring the command center into the title bar. Learn more about some of our own team members’ favorite customizations:

R language intelligence

Positron’s R language support now understands symbols within a file. You can rename a local symbol and have every use of it updated at once, and Go to Definition and Find References now work for local symbols, so you can jump to where a variable is defined (such as via <- or a function parameter) or see everywhere it is used within a function. Renaming symbols across files is not yet supported, but it is coming soon.

What’s coming next

• We have some exciting milestones planned for our July release! The new notebook editor for .ipynb files, the Packages pane, and Posit Assistant will all come out of preview to general availability. We are thrilled for these features to be ready for your production workflows, and we hope you will give them a try and share your feedback.
• We’re still prototyping first-class SQL editing and execution in Positron, including support for visualizations with ggsql. We’ll share more as this takes shape, and in the meantime, let us know your thoughts and current pain points!
• If you will be at the Databricks Data + AI Summit next week, join us to learn about using Positron and Workbench within the Databricks platform.
• We are looking forward to posit::conf(2026) in September, where our team will have several sessions on Positron. The conference program was released last week and we are pretty excited about everything happening! Register now to join us in person in Houston or virtually from anywhere in the world.

We (Emil Hvitfeldt, Jeroen Janssens, Michael Chow, and I) just got back from PyCon US 2026, and there was so much buzz around Polars. What is Polars? Why should I switch to Polars? How do I switch to Polars?

I mean, just check out the line for the book signing of Jeroen’s book, Python Polars: The Definitive Guide.

If Polars is new to you, it is a library for efficient data manipulation in Python. It’s built on Rust, so it’s super fast. And a lot of people (including the creator of Pandas!) like the intuitive way you write Polars code. However, if you work in Python, you might know that different DataFrames have different requirements, so you want to make sure to use libraries that support Polars (I admit, I come from the R world, and this was mind blowing to me).

And, we’re happy to say that we (Posit) have excellent Polars support across our Python libraries for every stage of the data science workflow! In this post, we’ll walk through four:

• pointblank for data validation and quality checks
• Great Tables for creating publication-quality tables
• plotnine for ggplot2-style visualizations
• mall for LLM-powered data analysis

Let’s check them out!

Setup

First, let’s install the libraries:

pip install polars great_tables pointblank plotnine mlverse-mall

Now, import what we need:

import polars as pl
from great_tables import GT
import pointblank as pb
from plotnine import (
    ggplot, aes, geom_point, geom_line, geom_bar, geom_text, geom_col,
    labs, theme_minimal, theme, element_text, scale_fill_manual,
    scale_y_continuous, element_rect, element_blank, element_line,
    scale_color_manual, position_dodge, annotate
)
import mall

The dataset

We’ll demonstrate these tools using sales_data, a sample sales dataset:

sales_data = pl.DataFrame(
    {
        "date": [
            "2026-01-15",
            "2026-01-16",
            "2026-01-17",
            "2026-01-18",
            "2026-01-19",
            "2026-01-20",
            "2026-01-21",
        ],
        "region": ["North", "South", "North", "West", "South", "North", "West"],
        "product": [
            "Widget A",
            "Widget B",
            "Widget A",
            "Widget C",
            "Widget B",
            "Widget A",
            "Widget C",
        ],
        "sales": [1200, 1800, 1500, 2100, 1650, 1900, 2300],
        "units_sold": [24, 36, 30, 42, 33, 38, 46],
        "customer_rating": [4.5, 4.8, 4.6, 4.9, 4.7, 4.8, 4.9],
    }
).with_columns(pl.col("date").str.strptime(pl.Date, "%Y-%m-%d"))

print(sales_data)

shape: (7, 6)
┌────────────┬────────┬──────────┬───────┬────────────┬─────────────────┐
│ date       ┆ region ┆ product  ┆ sales ┆ units_sold ┆ customer_rating │
│ ---        ┆ ---    ┆ ---      ┆ ---   ┆ ---        ┆ ---             │
│ date       ┆ str    ┆ str      ┆ i64   ┆ i64        ┆ f64             │
╞════════════╪════════╪══════════╪═══════╪════════════╪═════════════════╡
│ 2026-01-15 ┆ North  ┆ Widget A ┆ 1200  ┆ 24         ┆ 4.5             │
│ 2026-01-16 ┆ South  ┆ Widget B ┆ 1800  ┆ 36         ┆ 4.8             │
│ 2026-01-17 ┆ North  ┆ Widget A ┆ 1500  ┆ 30         ┆ 4.6             │
│ 2026-01-18 ┆ West   ┆ Widget C ┆ 2100  ┆ 42         ┆ 4.9             │
│ 2026-01-19 ┆ South  ┆ Widget B ┆ 1650  ┆ 33         ┆ 4.7             │
│ 2026-01-20 ┆ North  ┆ Widget A ┆ 1900  ┆ 38         ┆ 4.8             │
│ 2026-01-21 ┆ West   ┆ Widget C ┆ 2300  ┆ 46         ┆ 4.9             │
└────────────┴────────┴──────────┴───────┴────────────┴─────────────────┘

We can confirm that it is, indeed, a Polars DataFrame!

isinstance(sales_data, pl.DataFrame)

True

Data validation with pointblank

Let’s now validate our data quality using pointblank:

agent = (
    pb.Validate(sales_data)
    .col_vals_not_null(columns="date")
    .col_vals_between(columns="sales", left=0, right=10000)
    .col_vals_between(columns="customer_rating", left=1.0, right=5.0)
    .col_vals_in_set(columns="region", set=["North", "South", "East", "West"])
    .interrogate()
)

agent