PICkit Programmer Guide: What It Is and How It Works
If you want to program a physical PIC microcontroller, one of the first tools you are likely to encounter is the PICkit.
A PICkit is a hardware programmer and debugger from Microchip Technology. It connects your development computer to a microcontroller and allows software such as MPLAB X IDE or MPLAB IPE to transfer a compiled program into the target device.
PICkit tools can also provide debugging features on supported microcontrollers. Instead of simply programming the chip and hoping the firmware works, you can pause execution, set breakpoints, inspect program state, and investigate problems while the microcontroller remains installed in the circuit.
Several generations of PICkit programmers have been produced, including PICkit 2, PICkit 3, PICkit 4, PICkit 5, and the newer PICkit Basic. This guide explains how PICkit programmers work, what they are used for, how they connect to PIC microcontrollers, and how the different generations compare.
What Is a PICkit?
A PICkit is a development tool used to program and, where supported, debug Microchip microcontrollers and related devices.
During normal development, you write source code on your computer and compile or assemble it into machine code. The PICkit provides the hardware connection required to transfer that machine code into the non-volatile program memory inside the microcontroller.
Once programming is complete, the PIC normally executes the new firmware whenever it starts.
The PICkit therefore acts as a bridge between the development software running on your computer and the physical microcontroller on your board.
PICkit as a Programmer vs Debugger
The words programmer and debugger describe two related but different jobs that a PICkit can perform.
Programming
Programming means transferring firmware into the target microcontroller's program memory.
A typical programming operation includes:
- Compile or assemble the source code.
- Connect the PICkit to the target circuit.
- Select the correct microcontroller.
- Erase the device if necessary.
- Write the new program into Flash memory.
- Verify that the programmed data is correct.
Debugging
Debugging allows the development tools to interact with the microcontroller while your application is being tested.
Depending on the target device and debugger support, you may be able to:
- set breakpoints
- pause firmware execution
- single-step through source code
- inspect variables
- view registers
- watch memory values change
- continue execution after a breakpoint
This can make debugging considerably easier than repeatedly adding LEDs, serial print statements, or other temporary diagnostic code.
How Does a PICkit Connect to a PIC Microcontroller?
PIC microcontrollers commonly support In-Circuit Serial Programming, usually abbreviated as ICSP.
ICSP allows the microcontroller to be programmed while it remains installed in the target circuit. You therefore do not normally need to remove the PIC and place it into a separate programming socket every time the firmware changes.
A typical PIC ICSP connection uses several important signals:
- MCLR/VPP: Reset and programming-voltage connection.
- VDD: Target supply-voltage reference.
- VSS: Ground reference.
- PGD: Programming data.
- PGC: Programming clock.
The exact connector and signal requirements depend on the PICkit and target microcontroller, so you should always check the documentation for both devices before wiring the programmer.
What Is ICSP?
In-Circuit Serial Programming is Microchip's method for programming compatible devices through a small number of electrical connections.
The important part of the name is in-circuit. Once an ICSP header is included in your PCB design, firmware can be updated without removing the microcontroller from the board.
This is especially useful during development because firmware may be recompiled and programmed dozens or hundreds of times while a project is being tested.
A typical development cycle might look like this:
PICkit Versions
Microchip has released several generations of PICkit hardware over the years. Older versions remain common in electronics laboratories and on the second-hand market, while newer tools support more recent devices and development environments.
PICkit 2
PICkit 2 was an extremely popular low-cost Microchip programmer and debugger.
It supported many PIC families from its era and became common among students, hobbyists, and embedded developers.
It is now a legacy product and should generally be considered only when maintaining older hardware or existing development setups.
PICkit 3
PICkit 3 replaced PICkit 2 and became another widely used programmer and debugger for PIC and dsPIC devices.
Microchip no longer recommends PICkit 3 for new designs, and new device support is no longer being added.
PICkit 3 can still be useful when working with older PIC devices that it already supports, especially if you already own one.
PICkit 4
PICkit 4 introduced faster programming and broader device support than PICkit 3.
It also added support for device families beyond traditional PIC microcontrollers and included features such as Programmer-to-Go.
However, Microchip designated PICkit 4 as End of Life in 2023. Developers starting a new setup should therefore consider a newer tool rather than purchasing PICkit 4 solely because it was once the current generation.
PICkit 5
MPLAB PICkit 5 is Microchip's current full-featured PICkit programmer and debugger.
It supports a broad range of Microchip device families including PIC microcontrollers, dsPIC digital signal controllers, AVR devices, and SAM devices.
PICkit 5 connects to the development computer through USB Type-C and uses an 8-pin Microchip programming/debug connector on the target side.
It also includes a microSDHC card slot used for Programmer-to-Go functionality.
PICkit Basic
MPLAB PICkit Basic is a newer lower-cost programmer/debugger intended for developers who do not require all of the advanced features of PICkit 5.
It supports a broad selection of modern Microchip devices and connects through USB Type-C.
However, PICkit Basic does not provide high-voltage programming. Microchip therefore notes that some devices, particularly certain legacy parts or devices requiring high-voltage programming, are not supported.
PICkit 3 vs PICkit 4 vs PICkit 5
If you are choosing between PICkit generations, the age and support status of the tools matter as much as their original specifications.
PICkit 3
Suitable primarily for older supported PIC projects when you already own the tool.
It is no longer recommended for new designs and does not receive support for new devices.
PICkit 4
Faster and more capable than PICkit 3, but now an End-of-Life product.
It may still make sense for maintaining an existing development environment.
PICkit 5
The current full-featured PICkit generation and generally the most sensible PICkit choice when broad device support and modern debugging features are required.
PICkit Basic vs PICkit 5
The introduction of PICkit Basic creates another option for developers who find the full PICkit 5 unnecessary or too expensive for their needs.
PICkit Basic is aimed at lower-cost programming and debugging, while PICkit 5 provides a more complete feature set.
Consider PICkit Basic If
- your target device is officially supported
- you do not need high-voltage programming
- you primarily need basic programming and debugging
- cost is an important consideration
Consider PICkit 5 If
- you want broader device compatibility
- you work with multiple Microchip device families
- you require high-voltage programming features
- you want the more capable PICkit platform
Device compatibility should be checked before making the final choice. A cheaper programmer is not useful if it cannot program the specific microcontroller used in your project.
Using PICkit with MPLAB X IDE
PICkit programmers are designed to integrate with Microchip's software development environment.
A common setup uses:
- MPLAB X IDE for developing and debugging firmware
- MPLAB XC compilers for compiling C source code
- PICkit as the physical programmer/debugger
After connecting the PICkit, it appears as a hardware tool inside the project configuration.
The IDE can then use the selected PICkit when programming or debugging the target microcontroller.
Using PICkit with MPLAB IPE
MPLAB IPE, or Integrated Programming Environment, provides a programming interface for cases where you need to program a device without working directly inside the full MPLAB X development environment.
A typical use case is programming an already-built HEX file into a microcontroller.
A basic workflow is:
- Connect the PICkit to the computer.
- Connect the PICkit to the target board.
- Select the target device.
- Select the connected programming tool.
- Load the HEX file.
- Connect to the target.
- Program the device.
- Verify the programming operation.
Typical PICkit Programming Workflow
Suppose you have created a small PIC program that flashes an LED.
The complete physical development process might look like this:
- Write the firmware in assembly or C.
- Assemble or compile the source code.
- Correct any build errors.
- Connect the PICkit to your computer.
- Connect the PICkit programming signals to the target PIC.
- Select the correct device and programmer in MPLAB.
- Program the generated firmware into the PIC.
- Run the circuit and observe the LED.
- If the behavior is incorrect, enter debug mode or modify the code.
- Rebuild and reprogram the device.
This build-program-test cycle is repeated constantly during embedded development.
Does the PICkit Power the Target Circuit?
Target-power arrangements depend on the programming tool, target microcontroller, development software settings, and the electrical requirements of the circuit.
In many development setups, the target board has its own regulated power supply and the programmer uses the target voltage as a reference.
Some PICkit configurations can also provide power to suitable target circuits.
Always follow the PICkit documentation and the electrical requirements of your target board.
PICkit and Older PIC Microcontrollers
Many people learning PIC assembly use older devices such as the PIC16F84A because their architecture is simple and well documented.
However, programmer support changes as development tools evolve.
Before buying a modern PICkit specifically for an older PIC, check the current Microchip device-support list for that exact part number.
This is particularly important with PICkit Basic because Microchip explicitly states that the tool does not support some legacy devices and does not provide high-voltage programming.
Do You Need a PICkit to Learn PIC Programming?
Not necessarily.
A PICkit becomes necessary when you want to transfer your firmware into a compatible physical microcontroller.
If you are still learning assembly language, registers, GPIO, timers, interrupts, or basic program flow, a simulator allows you to practice many of these concepts before purchasing hardware.
PIC Simulator
Useful for learning code execution, assembly instructions, registers, GPIO, timers, interrupts, memory, and debugging concepts without physical hardware.
PICkit + Physical PIC
Required when you want to program a real microcontroller and test your firmware against actual electronic hardware.
A useful learning path is therefore:
Which PICkit Should You Buy?
The correct programmer depends primarily on the microcontroller you need to program.
Before buying any PICkit, answer these questions:
- What exact PIC microcontroller will I use?
- Does Microchip currently list that device as supported by this tool?
- Do I need only programming, or do I also need debugging?
- Does the target require high-voltage programming?
- Will I work only with PIC devices, or also AVR, SAM, or dsPIC devices?
- Do I need portable or Programmer-to-Go functionality?
For a new development setup, PICkit 5 is the more capable current PICkit option.
PICkit Basic may be attractive when cost is more important and your target device is supported without requiring features that PICkit Basic lacks.
PICkit 3 and PICkit 4 generally make more sense today when you already own the tool or need to maintain an established development setup.
Are There Alternatives to PICkit?
Yes. PICkit is only one family of Microchip programming and debugging tools.
Depending on device support, budget, and debugging requirements, Microchip also offers tools such as:
- MPLAB Snap
- MPLAB ICD
- MPLAB ICE
- MPLAB PICkit Basic
Third-party programmers also exist, but device compatibility, software support, firmware updates, and debugging capabilities can vary greatly.
If you primarily need an inexpensive tool, the first step should be to compare the official lower-cost options against the exact device you intend to program.
PICkit FAQ
What is a PICkit used for?
A PICkit is used to program firmware into compatible Microchip devices and, on supported targets, debug firmware while it runs on the microcontroller.
Is PICkit a programmer or debugger?
PICkit devices generally perform both roles. They can program firmware into a target device and can also provide in-circuit debugging features when the microcontroller supports them.
Is PICkit 4 still current?
No. Microchip designated PICkit 4 as an End-of-Life product in 2023. PICkit 5 is the newer full-featured PICkit generation.
Is PICkit 3 still usable?
Yes, for devices and software setups it already supports. However, Microchip no longer recommends PICkit 3 for new designs and does not add new device support to it.
What is PICkit Basic?
PICkit Basic is Microchip's lower-cost current programming/debugging option. It supports many modern Microchip devices but does not support high-voltage programming and therefore cannot support every legacy or special-case device.
What is the difference between PICkit 4 and PICkit 5?
PICkit 5 is the newer generation and is the current full-featured PICkit supported by Microchip. PICkit 4 is an older End-of-Life product.
Can I program a PIC without a PICkit?
Yes. Other compatible Microchip or third-party programmers can program PIC devices. The important requirement is that the programming tool supports the exact microcontroller being used.
Do I need a PICkit to use PIC Simulator?
No. PIC Simulator runs in your browser and simulates PIC program execution without requiring a physical programmer or microcontroller.
Can I use PIC Simulator before buying a programmer?
Yes. Simulation is a useful way to learn PIC assembly instructions, registers, GPIO, timers, interrupts, and debugging concepts before moving to physical hardware.
Official PICkit Resources
Programmer capabilities and device support can change as Microchip updates its development tools. Check the official documentation before choosing a programmer for a specific microcontroller.
Conclusion
A PICkit is the hardware link between your development computer and a physical PIC microcontroller.
It allows development software to program firmware into the device and, on supported microcontrollers, provides debugging capabilities that make embedded development much easier.
Older tools such as PICkit 3 and PICkit 4 remain common, but developers creating a new setup should consider current options such as PICkit 5 and PICkit Basic.
Whichever tool you choose, always check support for your exact microcontroller before purchasing it.
If you are still learning PIC programming and do not yet own a programmer, you can begin by experimenting with PIC assembly code directly in your browser.