[ANN] Swirl.jl - Interactive Julia Learning in the REPL :cyclone: Hi everyone! :waving_hand: I’m really happy to introduce Swirl.jl, an interactive platform that teaches Julia programming right inside the REPL. It’s inspired by the excellent swirl package for R, which has helped thousands of people get started with R programming. Why Swirl.jl? When I was learning R, swirl made the experience engaging and accessible; you could learn by doing, right in your console, with immediate feedback. I wanted to bring that same experience to Julia. swirl for R has been a tremendous success in lowering the barrier to entry for R learners and I hope Swirl.jl can play a similar role in helping more people adopt Julia. What is Swirl.jl? Swirl.jl is an interactive tutorial system that runs entirely in the REPL and there are no external tools needed. You type Julia code, get instant feedback, and learn by doing. After trying it out, feel free to give it a :star: on GitHub! Quick Demo julia> using Swirl julia> swirl() ============================================================ | Welcome to Swirl for Julia! 🌀 ============================================================ Available courses: 1. Julia Basics Select a course: 1 Lessons in Julia Basics: 1. [ ] Basic Math and Variables 2. [ ] Types and Functions 3. [ ] Vectors and Arrays Select a lesson: 1 --- Question 1 of 7 --- Let's begin! Julia can be used as a calculator. Try adding 5 + 3. julia> 5 + 3 8 ✓ Correct! --- Question 2 of 7 --- Now try multiplication. What is 7 * 6? julia> hint 💡 Hint: In Julia, multiplication uses the asterisk symbol: * Type: 7 * 6 julia> 7 * 6 42 ✓ Correct! How It Works Everything happens in the REPL: Real Code Execution: Your code runs in the actual Main module, so variables persist between questions and you can use any Julia features or packages Intelligent Evaluation: The system evaluates your expressions and checks if they produce the expected result, not just exact string matching Natural Interaction: You can explore and experiment - multi-step questions work naturally. For example, you can enter multiple commands on a single line by separating them with ; (e.g., define a variable and then use it in the same line). Smart Hints: When you type hint, you get detailed -and hopefully educational- explanations, not just “type this.” Auto-Save Progress: Your progress is automatically saved after each question, so you can stop and resume anytime even after ending the current REPL session. Technical Details Under the hood: Questions are evaluated using Core.eval(Main, ...) so your code runs in the same environment as your REPL The parser handles multi-statement code (semicolon-separated) and checks only the final result Progress is serialized to ~/.swirl_julia/progress/ for persistence The system supports different question types: messages, code evaluation, and multiple choice Features :sparkles: Interactive Learning - Type real Julia code, get immediate feedback :books: Structured Lessons - Work through well-designed courses :floppy_disk: Auto-Save Progress - Never lose your place :light_bulb: Smart Hints - Detailed help when you’re stuck :bullseye: Multiple Question Types - Mix of explanations, code, and quizzes :package: Custom Courses - Install courses from GitHub, URLs, or local directories :counterclockwise_arrows_button: Flexible Navigation - Easy menus with back/exit commands :video_game: Progress Management - Reset and retake lessons anytime Current Status The package includes a Julia Basics course covering: Basic Math and Variables Types and Functions Vectors and Arrays :rocket: Call for Contributors! This is where I need your help! The current course is quite minimal, just 3 lessons with a handful of questions each to demonstrate the system. The current built-in course is quite basic, just enough to showcase what the system can do. It would be exciting to see the Julia community help expand it into something comprehensive for Julia beginners. Even adding a few more questions to existing lessons or creating new lessons on basic topics would be incredibly valuable! Each lesson (should) include(s) carefully crafted questions with detailed, educational hints. Immediate needs: More questions for the existing Julia Basics lessons New lessons on basic Julia topics (e.g., loops, conditionals, strings, dictionaries, etc.) Better coverage of fundamental concepts (e.g., types and type composition) More diverse examples and exercises Longer-term vision: Besides adding new lessons to the Julia Basics course, Swirl.jl can also host new, independent courses. Imagine having new courses on: Julia for Python/R/MATLAB users DataFrames.jl and data wrangling Plotting (Plots.jl, Makie.jl) Statistics and machine learning Package development How to Contribute The system is designed to make course creation straightforward. A course is just a Julia file that organizes lessons, each made up of individual questions: Course( "Course Name", "Description", [ Lesson("Lesson 1", "Learn X", [ Question("Try 1+1", :code, 2, "Type: 1+1"), # ... more questions ]) ] ) I’ve included templates for creating courses and lessons in the repository to help you get started. You can: Create entirely new courses Expand the existing Julia Basics course Improve hints and questions Add advanced topics Installation using Pkg Pkg.add(url="https://github.com/atantos/Swirl.jl") Then just: using Swirl swirl() Learn More :open_book: GitHub Repository: github.com/atantos/Swirl.jl :page_facing_up: README: Full documentation and examples Why This Matters Learning programming should be interactive and engaging. Just as swirl helped make R more accessible, I hope Swirl.jl can help more people discover and learn Julia. The REPL is Julia’s superpower. It’s fast, interactive and it’s where we do our work. Why not make it a powerful learning environment too? A personal motivation: I’m particularly interested in helping people from the Humanities learn Julia. Interactive tools like Swirl.jl can help them build confidence with the language and then, hopefully, discover powerful packages for their work such as the recently created TextAssociations.jl package for calculating n-gram associations in texts/corpora, which will be submitted to the Julia registry soon. Making Julia accessible is essential for expanding its adoption in the Humanities and the Social Sciences, especially among people with non-traditional programming backgrounds. A note on development: Swirl.jl was developed with significant assistance from Claude 4.5, which made the development process incredibly productive. TL;DR: Interactive Julia tutorials in your REPL, inspired by R’s swirl. Currently includes one short course (Julia Basics) and welcomes community contributions to expand content and help more people learn Julia!

This is very cool. I remember starting to learn R with zero understanding of programming or computers through Swirl and a Coursera course (both from Johns Hopkins Biostatistics).

[image] TheCedarPrince: This is exactly something I was so excited about year’s ago being: GitHub - caseykneale/JuliaTutor.jl: Learn Julia from the REPL. The author, Casey Kneale, used to be quite prolific in the Julia ecosystem but I haven’t seen him around in nearly 4/5 years (oye, I am getting old). There may be some ideas there you could adapt to your work in Swirl.jl? Thank you so much for the kind words and for taking the time to try out Swirl.jl! I’m really glad to hear it’s working well for you. I really appreciate you pointing me to JuliaTutor.jl. I wasn’t aware of that project! I will definitely take a look and explore what concepts might translate well to Swirl.jl. It’s a bit bittersweet to hear about projects and contributors who’ve moved on from the ecosystem. Hopefully Swirl.jl can carry forward some of that interactive learning spirit and maybe even bring a few of those ideas back into active use. [image] TheCedarPrince: That said, bridging social sciences/humanities into Julia is such a fantastic endeavor. As someone who works in the biostats, public health, and census data worlds, R is the de facto tool of choice. I’ve been quietly exploring options on how to bridge worlds, but this seems like such a wonderful idea, Alex. It really means a lot to hear this perspective from someone working directly in those fields. As someone coming from a different background, I sometimes wonder if efforts like this will actually resonate with the communities that could benefit most from Julia’s capabilities. Hearing from someone actively working in biostats, public health, and census data that this approach feels valuable is incredibly encouraging and helps validate that this bridge-building work is worth pursuing. [image] TheCedarPrince: I hope you do not mind, but I would like to share some general thoughts as I found this extremely exciting and would like to share this excitement with some other folks. Not at all. I’m really glad it sparked that kind of excitement; that’s exactly what I was hoping for. This is fantastic feedback. Thank you! I will compile a list of potential features out of these bullet points that you pointed throughout your useful post and I’ll open GitHub issues to track each suggestion/design thought/idea so anyone can follow along, discuss about them and contribute to their implementation. [image] TheCedarPrince: Could we use the Julia REPL per use the actual julia REPL · Issue #4 · atantos/Swirl.jl · GitHub ? This keeps syntax coloring and could be used to display more visual information to the learner. Just touching on this point for now. I’m about to add REPL support shortly and will revisit this soon. [image] TheCedarPrince: This is exactly how I dreamed LLMs could be used. This is such a great use case of GenAI and I deeply appreciate the disclosure of its use. I wanted to mention that as I think you did that really great here. I’m really glad that came through, and it’s great to know it aligns with how you envisioned LLMs being used. I completely share that mindset. [image] TheCedarPrince: As I mentioned, my enthusiasm for this work here is quite high! I hope you’ll forgive this lengthy message without much action on my side, but I deeply resonate with this effort. While I am time-constrained, I am more than glad to follow-up and share thoughts here. Keep up the excellent, excellent work. I completely understand, I’m quite time-constrained myself too! Hopefully, little by little, as more of us find bits of time to contribute or share thoughts, the project can evolve and help more new people get started with Julia.

Really helpful and targeted feedback. Thanks! [image] tecosaur: :heart: I will definitely look at your package! [image] tecosaur: This reminds me of some work I started a while back on an interactive version of the Emacs tutorial for Doom. Sample: Impressive! [image] tecosaur: I made a format so that Doom modules could define their own tutorials. I imagine Swirl.jl could do something similar with packages/package extensions. We could really use your help on that! A setup like what you did for Doom modules is definitely worth considering for package-specific tutorials.

I’ve always thought Swirl was a brilliant idea for R users. I actually shared a similar entry experience to R myself.

Hi everyone Swirl now supports a fully interactive REPL mode powered by ReplMaker.jl, while still keeping the classic mode for backward compatibility. This makes Julia learning experiences smoother and more immersive right from your REPL. Below is a quick summary of what changed. TL;DR swirl() now runs in a ReplMaker-powered interactive REPL by default and can accept a keyword use_repl_mode to allow for setting either a ReplMaker-powered interactive REPL or a classic readline mode. Several functions were removed from the public API (breaking change). The parser and progress system were simplified. The classic mode remains available for backward compatibility. Here is a short demo video showing the new REPL mode in action! It walks through lesson selection, answering questions, and how to switch between modes. In the video, I intentionally inject a few user errors to showcase how Swirl responds. I missed to demonstrate navigationwhile responding to questions using hint → show detailed hint skip → skip current question restart → restart lesson menu → return to menu exit → exit swirl mode but I guess you can see all the details in the PR description i just opened.

From the screenshots, it looks like the user inputs a number to select an entry from a menu. If that is correct, then TerminalMenus.jl might provide a much smoother interface.

Having a peek at the package source code, I’m awfully tempted to try a tweaked approach :sweat_smile: slaps hand: bad Timothy, don’t start doing another thing.

Haha, I know that feeling @tecosaur , the eternal struggle not to start another side project :sweat_smile: Your reaction might just be the push I needed. looks like it’s time to merge the REPL-support PR (probably later tonight or tomorrow). Even with two unrelated talks to prepare this month, I somehow found myself working on Swirl anyway :grinning_face_with_smiling_eyes:

That’s a great point. And yes, right now it’s number-based. I’ll definitely take a look at TerminalMenus.jl; it seems like a great match for Swirl’s menu navigation once the REPL mode is fully merged.

Until now, Swirl for Julia worked in a classic readline-based mode. The latest update introduces REPL-based interaction, powered by ReplMaker.jl, meaning you can now enter Swirl lessons directly inside your REPL in `swirl> mode with syntax highlighting, persistent variables, and smooth transitions between questions. The README.md has been updated accordingly, and you can now experience exactly what’s shown in the short YouTube demo I shared in my earlier post. By default, Swirl.jl comes with a “Julia Basics” course consisting of three lessons (six questions each): Basic Math and Bindings Types and Functions Vectors and Arrays Of course, you can also create your own custom courses. Two template files are included to make that process easy. Before expanding further, though, I’d really appreciate hearing your thoughts on what topics or exercises should be part of the Julia Basics course. I know there are already plenty of learning resources out there, but this format feels quite different; more hands-on and interactive than traditional video tutorials or static exercises. Platforms like DataCamp used to offer something similar (with code and questions embedded directly in the console), typically around 15 questions per lesson (if I am right, am I?). I’m curious what you think would be a good balance here and I also feel that the hints could be improved to guide learners more effectively. On the technical side, the next step is to support multi-step questions or questions that can be written across multiple lines. At the moment, users need to join multi-step commands with a semicolon (;), which can be a bit of a hurdle for beginners. If you’ve used platforms like swirl in R or other interactive learning tools, I’d love to hear what worked well (or didn’t) and what you think could make Swirl.jl a better learning experience for new Julia users. :light_bulb:

Swirl.jl - Interactive Julia Learning in the REPL 🌀 - #24 by stevengj - Package Announcements

Topic		Replies	Views	Activity
Swirl for Julia? Teaching & Outreach question	4	953	November 6, 2025
RFC: JuliaTutor.jl Package Announcements	11	1739	May 3, 2021
Teaching Julia to Children Teaching & Outreach	29	1924	February 14, 2025
Guide the user through ?-REPL (Help mode) Internals & Design	14	1596	July 15, 2018
Issues encountered teaching classes with Julia for the first time New to Julia	140	10799	November 11, 2022

Swirl for Julia?

Teaching & Outreach

question

4

953

November 6, 2025

RFC: JuliaTutor.jl

Package Announcements

11

1739

May 3, 2021

Teaching Julia to Children

Teaching & Outreach

29

1924

February 14, 2025

Guide the user through ?-REPL (Help mode)

Internals & Design

14

1596

July 15, 2018

Issues encountered teaching classes with Julia for the first time

New to Julia

140

10799

November 11, 2022

Swirl.jl - Interactive Julia Learning in the REPL 🌀

Related topics