Introducing Thonny, a Python IDE for Learning
Programming
Aivar Annamaa
Institute of Computer Science
University of Tartu
aivar.annamaa@ut.ee
ABSTRACT
Thonny is a new Python IDE for learning and teaching pro-
gramming that can make program visualization a natural
part of the beginners’ workflow. Among its prominent fea-
tures are different ways of stepping through the code, step-
by-step expression evaluation, intuitive visualization of the
call stack and mode for explaining the concepts of references
and heap. It supports educational research by logging user
actions for replaying or analyzing the programming process.
It is free to use and open for extension.
CCS Concepts
•Social and professional topics → CS1; •Software and
its engineering → Integrated and visual development
environments;
Keywords
Computing education, Programming, IDE, Python, Pro-
gram animation, Program visualization
1. INTRODUCTION
In order to successfully learn imperative programming,
students must learn to regard the program interpreter as
a machine and relate language constructs with the corre-
sponding rules of this machine. Although these rules can be
described verbally, for many students this is not sufficient, so
different tools have been developed for visualizing program
behavior at runtime. According to the terminology given in
[13], we call these program animation systems.
Thonny is a new beginner-friendly Python IDE we de-
veloped in University of Tartu. Besides standard program
construction and execution capabilities, it has comprehen-
sive support for program animation. It has features to il-
lustrate the concepts of variables, control flow, expression
evaluation, function calls, recursion, references and heap,
objects (including classes and functions as values), compos-
ite data (lists, dictionaries and sets) and file IO. It can log
Permission to make digital or hard copies of all or part of this work for personal or
classroom use is granted without fee provided that copies are not made or distributed
for profit or commercial advantage and that copies bear this notice and the full citation
on the first page. Copyrights for components of this work owned by others than the
author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or
republish, to post on servers or to redistribute to lists, requires prior specific permission
and/or a fee. Request permissions from permissions@acm.org.
Koli Calling 2015, November 19 - 22, 2015, Koli, Finland
c 2015 Copyright held by the owner/author(s). Publication rights licensed to ACM.
ISBN 978-1-4503-4020-5/15/11. . . $15.00
DOI: http://dx.doi.org/10.1145/2828959.2828969
117
user actions in detail sufficient for replaying the program-
ming process.
According to the engagement level taxonomy developed in
[13], Thonny supports controlled viewing of students’ own
content, because users can choose the granularity of each
step during the program animation and they can animate
any Python 3 program.
Thonny has been successfully tested for one semester in
the context of a CS1 course at our university. It is free to
use, open source, and developed with the goal of supporting
extensions written by third parties.
2. BACKGROUND
For last 6 years we have been teaching Python based first
programming course (CS1) in our university. During this
time we have met many hardworking students constantly
struggling with programming exercises or even failing the
course. There have been even more students who fail be-
cause they give up trying. Most of them seem to approach
programming tasks without clear understanding how each
part of their programs affects Python’s behavior at run-
time. After having success with hand-drawn visualizations
(eg. how call stack manages recursive calls), we started look-
ing for an automated program animation tool.
In [13] Sorva et al. list four challenges which could be
tackled by a program animation system. First, some novices
tend to regard program constructs only as pieces of code
without thinking about their runtime behavior. Seeing the
code become “alive” during program animation could help
them create the connections between static and dynamic
aspects of a program.
Second problem is that beginners often attribute human-
like reasoning power to program interpreter, failing to see
it as a machine with bounded capabilities and clear rules.
Program animation systems present the program runtime
via a notional machine [2], and demonstrate that it is only
able to make clearly defined steps according to relatively
simple rules.
Even when the student acknowledges the interpreter as
just a machine, misconceptions about the precise meaning of
program constructs are easy to develop when the mechanics
of the runtime system is hidden from the user.
Finally, students with correct understanding of the pro-
gram semantics may still struggle with program tracing, be-
cause of cognitive effort required for keeping track of pro-
gram state. Program animation systems can help reducing
the load here by externalizing program state representations.
We have met all these problems in our practice and we
 Figure 1: Thonny in stepping mode
believe Thonny can help with all of these. We describe our
approach in Section 4.
In their survey Sorva et al. conclude that program anima-
tion systems tend to have positive impact on learning pro-
gramming, but are often short-lived research prototypes, not
suitable for widespread use [13]. They suggest that success-
ful program animation tool should integrate content creation
and animation features, be able to adapt to their users’ grow-
ing knowledge and have sustainable development model.
With Thonny, our goal has been to offer single environ-
ment which integrates all the tools necessary for first pro-
gramming course. Each of these has been designed with be-
ginners in mind, unlike similar features in professional IDE-
s, which aim for greatest user performance and require much
steeper learning curve. Thonny allows gradual introduction
of different features in order to keep the user interface as
simple as possible in the beginning.
While we believe the features built into Thonny will suffice
for most introductory programming courses, we acknowl-
edge that different instructors and researchers have different
interests and preferences, therefore we made Thonny open
source and we embrace enhancements and extensions.
3. BASIC USAGE
Thonny is free software – both free to use and open source.
Installers and installation instructions are provided for Win-
dows, Mac OS and Linux [1].
On first run the window with an empty editor and a
Python shell is shown, other features can be enabled from
the View menu as required.
118
Figure 2: Different output formatting in the shell
In basic usage, our aim is to cover all the functionality
offered by Python’s standard graphical environment, IDLE.
Thonny’s editor supports standard IDE features like syntax
coloring, code completion, parentheses matching, automatic
indentation, block indentation / de-indentation, block com-
menting and uncommenting. It is possible to switch between
several files opened under different tabs. For easier file man-
agement, it is possible to open a file browser view as present
in many professional IDE-s.
The shell includes some minor enhancements compared
to IDLE’s shell. First, it is always shown below the edi-
tor. We believe this makes the user experience smoother
and encourages using the shell for small experiments more
often. Second, as seen in Figure 2, the text corresponding
to program input/output is formatted differently compared
to the results of direct expression evaluation. This reminds
users that automatic printing of the value of an expression
is a special feature of the shell and in scripts one needs to
request printing explicitly.

Figure 3: Thonny in the middle of evaluating an
expression
4. PROGRAM ANIMATION
Program animation – visualization of programs’ run-
time concepts – has been the main motivation for creating
Thonny. In this section we describe the features supporting
it.
4.1 Variables
After the students have become comfortable with
Thonny’s basic features, we ask them to open the variables
view containing a two-column table with names and values
of global variables. The entries are added and updated auto-
matically. This approach is similar to several other systems
[12, 11]. Some program animation systems display variables
as labeled boxes [14, 9, 10]. For Thonny we chose the table,
because this makes it easy to explain how Python looks up
the value of a variable.
4.2 Statement stepping
Executing the program in stepping mode begins by auto-
matically highlighting the first statement.
Highlighted statement can be executed with single key
press which invokes the command “Step over”. This executes
the whole statement even if it is a compound (eg. while
loop). After updating variables table and shell, the next
statement is highlighted automatically.
If the same key is pressed with modifier key (Control in
Windows), Thonny executes the command “Step into” and
tries to highlight the first child of current statement (eg.
loop condition). If current construct doesn’t have children,
it is executed and next construct is selected.
If the user double-clicks on a code line, the program ani-
mation will be fast forwarded to this line. This is our sub-
stitute for breakpoints.
In most systems statement stepping is implemented with
the granularity of code line, but we believe operating on
statements makes more sense when learning the connec-
tions between program static structure and runtime behav-
ior. The choice between “Step into” and “Step over” is present
in most IDE-s but only in the context of function calls. We
believe allowing stepping into or over any compound con-
struct is good for illustrating the nested structure of a pro-
gram. For the sake of simplicity, though, we use only “Step
into” during our first stepping demonstrations,
4.3 Expression evaluation
When “Step into” is issued on an expression, Thonny
opens a small box hovering above the original expression,
showing the copy of the expression. Figure 3 shows Thonny
in the middle of evaluating the expression 2*a + a**2. In
this box “Step into” works like in statement level by select-
ing the first child of current expression. “Step over” replaces
current expression with its value.
After the whole expression gets evaluated, the box is hid-
den and the focus goes back to the statement level.
119
Surprisingly, stepping through the evaluation of an expres-
sion is not common in professional IDE-s. It is supported
by some program animation systems [10, 11, 14], but unlike
Thonny, these systems reserve a separate pane for evaluat-
ing the expressions. According to Mayer, putting related
items closer to each other reduces the cognitive load for in-
terpreting them [8]. We believe the same principle applies
here and expression evaluation closer to the original source
creates smoother user experience.
4.4 Function calls
After evaluating the last argument in a function call, the
whole call expression gets focused again. If the user now
chooses to step into, Thonny opens a small window for exe-
cuting the function body 1.
Here stepping works just like on program’s top level. If
another function call is stepped into, a new window is cre-
ated and execution is continued there. After executing the
return statement or last statement of the function, the win-
dow is destroyed and original call expression gets replaced
by the return value.
Professional IDE-s usually have a separate view listing
the frames of call stack and reuse code editor for animating
the steps inside the function. This might be optimal for
users who already know how function calls work, but for
beginners this scheme can be confusing. We have seen many
students who fail to understand recursion because they try
visualize recursive calls as jumps in the source code without
understanding that each call creates a new context. We
believe Thonny’s way of presenting each stack frame in a
separate window, with its own code view and local variables
table, is more suitable for beginners. Similar approach is
used in VisMod [5] and Ville [12].
4.5 Object inspector
Selecting “Object inspector” in View menu opens a view
showing details (type, attributes, etc.) about the value cur-
rently selected in a variables table. For string objects the
inspector presents a text box showing the content of the
string – this reduces confusion about character escaping re-
quired by Python syntax. For collections (lists, sets and dic-
tionaries) it shows the table with collection’s elements. For
function objects it shows the source code of the function.
For text file handles the content of the file and the current
position in the file are shown – this helps understanding the
side effects of file manipulation methods.
4.6 Values in heap
As long as students are using only immutable data types,
like integers or strings, Python instructors are free to ignore
the complex issue of references and shared data. With lists
and other mutable types this issue needs to be addressed.
For explaining the concept of references and heap, Thonny
offers another mode of visualizing memory. When “Show val-
ues in heap” is enabled in View menu, the values in variable
tables get replaced by the ID-s of corresponding objects and
another table titled “Heap” appears, which maps ID-s to val-
ues, as seen in Figure 4. This makes it easy to demonstrate
that y = x only copies the ID given in x to y. Value rep-
resentations are replaced with ID-s also in shell, expression
evaluation box and attributes in object inspector.
There are many program animation systems [4, 10, 11, 9,
3] which display references as arrows between objects. We

Figure 4: Variables, heap and object inspector in
heap mode
acknowledge this might be more intuitive way for introduc-
ing the notions of dependency and sharing, but it doesn’t
scale well to many objects and complex data structures.
However, we will consider adding an additional view for vi-
sualizing the connections between objects graphically.
5. USER ACTION LOGGING
For each usage session Thonny creates a log file containing
descriptions of the actions performed by the user. These
actions include loading and saving files, modifications to the
program text (paste can be distinguished from typed text),
program executions, writes into and reads from program’s
standard streams, stepping commands, losing and gaining
the focus of Thonny window, etc. Each action gets recorded
together with its time stamp.
The collected information can be used to replay the whole
process of program construction and the activities in the
shell. For this Thonny provides a separate window where
one can choose a log file and see the events replayed in se-
lected speed.
6. IMPLEMENTATION
Thonny is written in Python 3. The source code is avail-
able under GPLv3 license at [1].
At runtime Thonny uses two processes – the GUI front-
end based on Tkinter framework, and the back-end for run-
ning user code. At the moment both processes need Python
3.2 or later, but it’s not difficult to add support for older
Python versions in the back-end.
Unlike some systems which support limited subset of tar-
get language features, eg. [14], Thonny supports all Python
3 programs. To achieve this, its stepping mode relies on
120
Python’s built-in tracing facilities. In order to provide
tracer precise information about current position in code
and to allow more fine-grained steps, marker nodes are
added to program syntax tree before compiling and exe-
cuting it. For each statement we add 2 dummy statement
nodes, one to be executed just before and the other just af-
ter the original statement. The code in these marker state-
ments provides the tracer information about the location
of the original statement, whether the statement has chil-
dren, etc. Similarly, each expression is complemented with
two marker expressions, one to notify tracer that certain
expression is just to be evaluated and other to fetch the
value of the expression. Basically, each (sub)expression e
becomes after(before(info), e), where before and after are
marker functions and info is information about the location
and other features of the expression e.
Inspired by Java-based BlueJ’s [6] extension system we
included a simple plug-in system in Thonny, which allows
writing third party extensions without modifying the main
code. For validating this system, several features in Thonny
are implemented as plug-ins.
7. USAGE EXPERIENCE
Thonny has been used for one semester in the CS1 course
in University of Tartu. The course had 280 participants,
half of them were first year CS students, other half con-
sisted mostly of students from related fields (mathematics,
statistics, IT).
In selected lectures we used Thonny’s stepping mode for
demonstrating the principles of variables, control flow, ex-
pression evaluation, function calls, recursion and shared mu-
table data. Quick polls at the end of those lectures revealed
that majority of the students (usually more than 70%))
thought Thonny helped them understand these principles.
We encouraged students to use Thonny by themselves,
but also warned that at the moment it is not as stable as
IDLE, our official environment. At least 70 students in-
stalled Thonny on their computers and tried to use it. In
the labs Thonny was equally popular among weaker and
stronger students. We didn’t offer any support materials
for using program animation features – demonstrations in
the lectures were sufficient to get interested students able to
trace their programs with Thonny.
Before one of the midterms we offered students extra credit
if they solve the programming exercises in Thonny, answer
couple of questions and send us the log files describing their
actions during the midterm. We got logs and responses from
44 students. Most of the students said Thonny helped them
in debugging their programs and gave them advantage over
IDLE users during the midterm (the rest were mostly an-
noyed by a bug in code editor that was fixed later). Many
students mentioned that they liked that Thonny keeps editor
and shell in the same window.
We haven’t used Thonny action logs for any serious anal-
ysis yet, but for proof of the concept we created a small
summary on the logs collected during the midterm. From
this data we learned, for example, that one third of the pro-
gram executions generated error messages of which one third
were syntax errors and that only 14 students out of 44 had
used Python shell for executing statements or evaluating ex-
pressions. We also replayed some of the logs in Thonny and
discovered some curious working patterns we hadn’t noticed
during the labs.
8. FUTURE WORK
Among the specific features we plan to implement soon are
visualization of raising, propagating and catching exceptions
and features for explaining principles of Python’s module
system. After completing these, Thonny can be used for
visualizing all Python’s core concepts.
A prototype already exists which allows Python programs
to be constructed by dragging and dropping code blocks in
the style of Scratch [7], hopefully this can be integrated with
Thonny soon.
Other possible directions we see for Thonny are integra-
tion with an automatic feedback service, filters for uncaught
exceptions trying to reformulate the problem in beginner-
friendly way, different static analyses which help locate the
mistakes in the code and automatically generated quizzes
for testing users’ understanding of their programs.
We also hope other instructors and researchers find
Thonny’s plug-ins system suitable for extending Thonny’s
capabilities in directions important for them.
In parallel with enhancing Thonny, we plan to conduct
experiments and surveys to evaluate its effect to learning.
9. CONCLUSION
In this paper we described Thonny, a new Python IDE
for learning programming. Besides standard program con-
struction tools it includes several program animation tools
capable of visualizing core concepts of imperative program-
ming (including variables, control flow, expression evalua-
tion, function calls, references and heap). Some of these
features are novel (support for commands “Step into” and
“Step over” on all levels of the program tree) or little used
in earlier systems (representing stack frames as cascading
windows). Unlike some systems with similar capabilities, it
supports all Python 3 programs. It can be used as a tool for
collecting data about the process of programming.
During a semester of using Thonny in the context of first
programming course in our university we received encour-
aging feedback from the students – they thought program
animations presented with Thonny helped them learn new
programming constructs. Majority of the students using
Thonny during a midterm said it helped them with debug-
ging. Thonny’s user interface is suitable for beginners –
most of the students who decided to install Thonny on their
own computers were able to use its features without further
assistance.
By rethinking standard approaches to program animation
we have managed to make basic program animation accessi-
ble to total beginners. At the same time, Thonny can grow
with its users – there are several layers of advanced fea-
tures to be enabled on demand. By integrating animation
tools with program construction tools, we created an envi-
ronment covering the needs of most instructors and students
in Python-based introductory programming courses.
Thonny is open source and free to use. It has potential for
becoming a useful platform for Python-based tools related
to learning and teaching programming.
10. REFERENCES
[1] Thonny source code repository and installers.
https://bitbucket.org/plas/thonny/.
[2] B. D. Boulay. Some difficulties of learning to program.
Journal of Educational Computing Research,
121
2(1):57–73, 1986.
[3] J. H. Cross II, T. D. Hendrix, J. Jain, and L. A.
Barowski. Dynamic object viewers for data structures.
ACM SIGCSE Bulletin, 39(1):4–8, 2007.
[4] P. J. Guo. Online python tutor: Embeddable
web-based program visualization for cs education. In
Proceeding of the 44th ACM technical symposium on
Computer science education, pages 579–584. ACM,
2013.
[5] R. Jiménez-Peris, M. Patino-Martinez, and
J. Pacios-Martı́nez. Vismod: a beginner-friendly
programming environment. In Symposium on Applied
Computing: Proceedings of the 1999 ACM symposium
on Applied computing, volume 28, pages 115–120,
1999.
[6] M. Kölling, B. Quig, A. Patterson, and J. Rosenberg.
The bluej system and its pedagogy. Computer Science
Education, 13(4):249–268, 2003.
[7] J. Maloney, M. Resnick, N. Rusk, B. Silverman, and
E. Eastmond. The scratch programming language and
environment. ACM Transactions on Computing
Education (TOCE), 10(4):16, 2010.
[8] R. E. Mayer. Multimedia Learning. Cambridge
University Press, 4 2001.
[9] J. Moons and C. De Backer. The design and pilot
evaluation of an interactive learning environment for
introductory programming influenced by cognitive
load theory and constructivism. Comput. Educ.,
60(1):368–384, Jan. 2013.
[10] A. Moreno, N. Myller, E. Sutinen, and M. Ben-Ari.
Visualizing programs with jeliot 3. In Proceedings of
the working conference on Advanced visual interfaces,
pages 373–376. ACM, 2004.
[11] T. S. Norvell and M. P. Bruce-Lockhart. Taking the
hood off the computer: Program animation with the
teaching machine. In Canadian Electrical and
Computer Engineering Conference, Halifax, Nova
Scotia, 2000.
[12] T. Rajala, M.-J. Laakso, E. Kaila, and T. Salakoski.
Ville: A language-independent program visualization
tool. In Proceedings of the Seventh Baltic Sea
Conference on Computing Education Research -
Volume 88, Koli Calling ’07, pages 151–159,
Darlinghurst, Australia, Australia, 2007. Australian
Computer Society, Inc.
[13] J. Sorva, V. Karavirta, and L. Malmi. A review of
generic program visualization systems for introductory
programming education. Trans. Comput. Educ.,
13(4):15:1–15:64, Nov. 2013.
[14] J. Sorva and T. Sirkiä. Uuhistle: A software tool for
visual program simulation. In Proceedings of the 10th
Koli Calling International Conference on Computing
Education Research, Koli Calling ’10, pages 49–54,
New York, NY, USA, 2010. ACM.