When working with 8-bit AVR microcontrollers, choosing the right programmer is essential. Whether you’re a beginner learning the ropes or a seasoned embedded developer, understanding the AVR programmers available to program these chips can save you hours of frustration and debugging.
Over the years, Atmel (now Microchip) has produced several official AVR programmers. Some, like the AVR Dragon and AVRISP mkII, are now discontinued or hard to find. Others have been replaced with modern solutions like the PICkit 5, which supports both PIC and AVR microcontrollers.
You’ll also find a wide variety of clones and affordable alternatives on the market—such as the popular USBasp—which cater to hobbyists and makers on a budget. In this guide, we walk you through the types of programmers available, the protocols they support, and which microcontrollers they work with.
Table of Contents
AVR Programming Protocols and Microcontroller Families
Before diving into the programmers themselves, it’s important to understand the different types of 8-bit AVR microcontrollers and the programming methods they use. These are covered below.
AVR ISP (In-System Programming)
This is the traditional programming protocol used for older AVRs like the ATmega328P and ATtiny85. It uses a 6-pin (or sometimes 10-pin) interface and is supported by most classic tools, including the AVRISP mkII, USBasp, and Arduino ISP.
The following diagram shows the ISP SPI programming connections to ATtiny13, ATtiny25, ATtiny45 and ATtiny85 microcontrollers. As can be seen in the diagram, four of the microcontroller pins are used by AVR programmers using this programming interface.
debugWIRE
Certain AVR microcontrollers, such as the ATtiny85 and ATmega328P, support debugWIRE (in addition to ISP), a protocol used for debugging over a single wire. It shares the RESET line, which limits some use cases but allows basic debugging via tools like the Atmel-ICE.
In AVR microcontrollers that support debugWIRE, debugWIRE is switched off by default. The usual procedure is to connect to the device using the AVR ISP interface. After this, the DWEN (debugWire Enable) fuse in the microcontroller is used to enable the debugWIRE interface.
The following diagram shows the debugWIRE interface to 8-pin ATtiny microcontrollers including the ATtiny25, ATtiny45 and ATtiny85. The AVR programmer used in this interface must have debugWIRE capabilities.
JTAG Support on AVR Microcontrollers
Some higher-end ATmega and XMEGA microcontrollers include support for the JTAG (Joint Test Action Group) interface. While less common in hobbyist setups, JTAG is widely used in professional environments for in-system programming, boundary scan testing, and full-featured debugging.
JTAG can be used with official tools like the Atmel-ICE or AVR Dragon, which support both JTAG and other interfaces like ISP, UPDI, and debugWIRE. JTAG requires four lines (TDI, TDO, TMS, and TCK), and it provides more powerful debugging capabilities than debugWIRE or UPDI, making it a great choice when working with complex applications or RTOS-based systems.
Although not as widely used in modern 8-bit development (with UPDI becoming the new standard), JTAG is still relevant for those maintaining or developing on older hardware platforms where it’s available.
TPI (Tiny Programming Interface)
Used in very small devices like the ATtiny10, TPI is a minimal protocol designed for low-pin-count microcontrollers. It is a ‘program only’ interface that does not have debugging capabilities.
In the following image, the TPI interface is shown. It uses three of the microcontroller pins to connect to the AVR TPI programmer. In addition to the three microcontroller pins, Vcc and GND also connect to the programmer.
UPDI (Unified Program and Debug Interface)
New AVR microcontrollers from the ATtiny 0/1/2 series, ATmega 0 series, and AVR Dx / AVRxx Series now use the UPDI protocol. It’s a single-pin interface that replaces ISP and debugWIRE. To use this protocol, you’ll need a UPDI programmer like the official Atmel-ICE, MPLAB SNAP, or a DIY UPDI adapter based on an FTDI or CH340 USB-to-serial converter.
The following diagram shows the UPDI interface connected to 8-pin AVR microcontrollers. This example circuit shows the UPDI interface on the ATtiny202, ATtiny402, ATtiny212, and ATtiny412 AVR microcontrollers. An UPDI AVR programmer connects to a single pin of an AVR microcontroller, as well as to Vcc and GND of the circuit.
Types of AVR Programmers
Let’s go over the various AVR programmers available, from official tools to budget-friendly clones and DIY options.
1. Modern Programmers
Modern AVR programmers are designed to support the latest 8-bit AVR microcontrollers using newer programming protocols like UPDI. Unlike older tools limited to AVR ISP or debugWIRE, these modern programmers—developed by Microchip—offer broader compatibility, faster programming, and better integration with actively maintained tools like MPLAB X IDE.
Whether you’re working with legacy ATmega chips or newer AVR Dx series devices, using a reliable modern programmer ensures a smoother development experience.
PICkit 5
Modern AVR programmers have evolved to support both legacy and next-generation 8-bit AVR microcontrollers. A great example is the PICkit 5, a dual-purpose programmer and debugger designed by Microchip to handle both PIC and AVR devices.
Unlike older Atmel programmers, the PICkit 5 is supported in MPLAB X IDE, Microchip’s modern development environment. This makes it a solid choice for embedded developers who want a future-proof tool. It fully supports the UPDI protocol used by new AVR chips and offers faster, more reliable programming than many older or budget tools.
The MPLAB PICkit 5 In-Circuit Debugger is Microchip’s newest USB programmer / debugger at the time of writing. It supports JTAG, SWD, UART VCP, ICSP, and AVR protocols.
- Microchip’s latest all-in-one tool
- Supports both PIC and AVR microcontrollers
- Compatible with MPLAB X
- Ideal for professionals who work across platforms
MPLAB SNAP
The MPLAB Snap In-Circuit Debugger / Programmer is lower cost than the PICkit 5 and supports debugging and programming of PIC, dsPIC, AVR and SAM flash MCUs and MPUs, using the MPLAB X Integrated Development Environment (IDE) version 5.05 or later.
- Affordable official programmer/debugger
- Supports UPDI, ISP, and other interfaces
- Slightly limited compared to the PICkit 5 but great for beginners
2. Official Atmel/Microchip AVR Programmers (Legacy)
Before the Microchip acquisition and the move to newer tools, Atmel programmers were the go-to solution for working with 8-bit AVR microcontrollers. Legacy AVR programmers like the AVRISP mkII, AVR Dragon, and Atmel-ICE offered robust support for protocols such as AVR ISP, debugWIRE, and even JTAG.
These tools were tightly integrated with Atmel Studio, providing debugging and programming features that served both hobbyists and professionals. While many of these programmers are now discontinued or harder to find, they remain valuable for working with older AVRs still in use across countless embedded projects.
Atmel-ICE Programmer and Debugger
The Atmel-ICE programmer / debugger is still available from Microchip. It is a development tool for debugging and programming ARM Cortex-M based SAM and AVR microcontrollers with on-chip debug capability. It supports JTAG, SWD, PDI, TPI, aWire, SPI, debugWIRE and UPDI interfaces
- Supports ISP, UPDI, TPI, and debugWIRE on 8-bit AVR devices
- One of the most versatile tools
- Still available from some suppliers and supported in Microchip Studio
AVR Dragon
The now obsolete AVR dragon was a low cost development tool for 8-bit and 32-bit AVR devices with On Chip Debug (OCD) capability. It can perform a symbolic debug on all devices with OCD with SPI, JTAG, PDI (selected devices), high voltage serial programming, parallel programming, and aWire modes, and supports debugging using SPI, JTAG, PDI interfaces.
- Supported a wide range of interfaces: ISP, HVPP, HVSP, JTAG, debugWIRE
- Discontinued, but powerful if you can find one second-hand
AVRISP mkII (AVRISP programmer)
The now obsolete AVRISP MKII was used for field upgrades of 8-bit AVR microcontrollers with ISP or PDI interfaces.
- Classic USB Atmel programmer for AVR ISP
- No longer sold, but widely cloned
- Often recognized as avr isp mk2 or avr avrisp mkii
3. Hobbyist and Clone AVR Programmers
For budget-conscious makers and hobbyists, there’s a wide range of hobbyist and clone AVR programmers available that offer great value for 8-bit AVR development. Popular tools like the USBasp and Arduino ISP are commonly used for basic AVR ISP programming and are supported by tools such as AVRDUDE.
These low-cost alternatives often come as open-source designs or cheap clones and can be used to program a variety of classic AVR chips. While they may lack advanced features like debugging or UPDI support, they’re perfect for simple projects, educational use, and getting started with AVR programmers on a tight budget.
USBasp
- Open-source USB programmer
- Supports AVR ISP programming
- Widely used in the maker community
- Cheap and well supported by tools like AVRDude
- Works with legacy AVRs but not UPDI devices
One version of the USBasp is shown below. These AVR programmers come in different forms from different manufacturers, so you may have a USBasp that looks different from the one in the image.
Arduino ISP
- Uses an Arduino as a programmer
- Great for Arduino ISP programming projects or bootloader burning
- Requires basic wiring and setup but is highly flexible
DIY UPDI Programmer
- Can be built using a USB-to-Serial adapter (like CH340 or FTDI)
- Supports UPDI devices using pymcuprog or jtag2updi firmware
- Inexpensive and reliable for programming new AVRs
An example of a CH340 UPDI hobby AVR programmer is shown in the image below.
AVR ICSP Programmer / AVR ISP Programmer / AVR ISP USB Programmer / USBtinyISP AVR Programmer
- “AVR ICSP programmer” usually refers to any ISP-compatible tool
- The same programmer may also be referred to as a AVR ISP programmer or AVR ISP USB programmer
- USBtinyISP AVR Programmer refers to a particular variant of a hobby AVR ISP programmer that uses an ATtiny chip in the programmer
- Be careful when buying online—some tools are mislabelled or low-quality clones
As with the USBasp, the USBtinyISP programmer comes in many different forms from many different manufacturers. An example of one of these programmers is shown in the image below.
AVR Programming Software
While choosing a programmer is important, you’ll also need compatible software:
- AVRDude – Command-line tool used with USBasp, Arduino ISP, and more
- Microchip Studio – Official IDE supporting Atmel-ICE and legacy Atmel tools
- MPLAB X IDE – Supports newer tools like PICkit 5 and MPLAB SNAP
- pymcuprog – Python tool supporting modern Microchip programmers and UPDI
Tips for Choosing the Right AVR Programmers
- For classic AVR chips (e.g. ATmega328P): USBasp, USBtinyISP, or Arduino ISP is fine for program only functionality. To debug, use Atmel-ICE, MPLAB SNAP, PICkit5, or AVR Dragon if you have one.
- For new UPDI-based chips (e.g. ATtiny1616): Go for Atmel-ICE, MPLAB SNAP, PICkit5 or a DIY UPDI adapter.
- For professional development: PICkit 5 or Atmel-ICE offer the best features and debugging support.
- On a budget? USBasp and Arduino ISP are great starting points, but remember that you are limited to the older range of AVR microcontrollers, such as the ATmega328 and ATtiny85. For the new range of UPDI programmed devices, get a DIY UPDI programmer.
Final Thoughts on AVR Programmers
Whether you’re flashing bootloaders with an Arduino, experimenting with new UPDI chips, or building commercial-grade devices, there’s an AVR programmer that fits your needs. From the robust Atmel-ICE to the budget-friendly USBasp, the ecosystem around AVR programming continues to evolve with both official and community-driven solutions.
By understanding the programming protocols, tool options, and microcontroller families, you’ll be better equipped to start building, debugging, and optimizing your embedded systems.
You may also be interested in our 8-bit AVR microcontrollers for beginners article and our beginner’s guide to embedded systems.