TinyCore is based on ATtinyCore and includes several improvements, such as the space-saving Urboot bootloader.<\/p>\n
Here’s what you can expect in detail:<\/p>\n
- \n
- The classic ATtinys<\/a><\/li>\n
- Pinout \/ Pinmapping<\/a><\/li>\n
- Installing TinyCore in the Arduino IDE<\/a><\/li>\n
- Burning the bootloader<\/a>\n
- \n
- Burning the bootloader with an “Arduino as ISP”<\/a><\/li>\n
- Burning the bootloader with a dedicated programmer<\/a><\/li>\n<\/ul>\n<\/li>\n
- Uploading sketches<\/a>\n
- \n
- Uploading sketches via ISP<\/a><\/li>\n
- Uploading sketches with a USB-to-TTL adapter<\/a><\/li>\n
- Uploading via ISP and using the serial monitor<\/a><\/li>\n<\/ul>\n<\/li>\n
- Micronucleus Bootloader \u2013 Let us build a Digispark<\/a><\/li>\n
- Further features of the TinyCore board package<\/a><\/li>\n<\/ul>\n
This article repeats much of what I wrote about the MiniCore package in my last article. Regular readers may find this boring, but each post should be understandable on its own. <\/p>\n\n
The classic ATtinys<\/h2>\n
TinyCore covers the following classic ATtinys and boards based on them:<\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/attiny_properties_overview-1024x601.png\")
<\/a>Selected properties of the classic ATtinys<\/figcaption><\/figure>\n With their sometimes minuscule RAM and flash memory, the ATtinys seem somewhat outdated, yet they remain highly popular. From a technical point of view, the newer models in the tinyAVR\u00ae series 0 to 3 are almost always the better choice (see this article<\/a>). However, the classic ATtinys are favoured by their widespread use and the resulting abundance of articles, tutorials, and forum posts. Added to this is their availability in PDIP version and their comparatively simple and therefore easy-to-understand architecture. In any case, as far as I\u2019m concerned, they\u2019re still worth writing a post about. <\/p>\n\n
Pinout \/ Pinmapping <\/h2>\n
In this article, the ATtiny85 is my standard example. Here is the corresponding pinout diagram of the PDIP variant, which is also valid for the ATtiny45 and the ATtiny25: <\/p>\n\n
![\"Pinout\/Pinmapping](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/attiny85_pinout_schematic-1024x206.png\")
<\/a>Pinout ATtiny25\/45\/85<\/figcaption><\/figure>\n Some of the pin functions are defined on the hardware side, others are assigned via the board package. The pinout diagrams of the other ATtinys can be found here<\/a>. <\/p>\n\n
Installing TinyCore in the Arduino IDE<\/h2>\n
Installation is completed in two minutes:<\/p>\n
- \n
- Go to File \u2192 Preferences and click on the green icon next to “Additional boards manager URLs”.<\/li>\n
- Then enter the following as a separate line:\n
- \n
- https:\/\/mcudude.github.io\/TinyCore\/package_MCUdude_TinyCore_index.json<\/li>\n<\/ul>\n<\/li>\n
- Confirm twice by clicking on “OK”.<\/li>\n
- Then go to the boards manager via the board icon on the left-hand side of the program window. Alternatively, you can navigate there via Tools \u2192 Board \u2192 Boards manager. <\/li>\n
- Enter “TinyCore” in the search field and choose “TinyCore by MCUdude” among the hits.<\/li>\n
- Click on “Install” – and that’s it.<\/li>\n<\/ul>\n
Problems? Then you will find detailed instructions for installing board packages here<\/a>. <\/p>\n\n
Burning the bootloader<\/h2>\n
In my last post about the MiniCore board package, I covered the basics of bootloaders, fuses and programming methods in quite some detail. If you need or are interested, take a look here<\/a>. In this article, I would just like to briefly summarize again: <\/p>\n
- \n
- For uploading programs to a “naked” ATtiny you can use an ISP programmer or a USB-to-TTL adapter. <\/li>\n
- To use the USB-to-TTL adapter, you must first burn a bootloader. This in turn requires an ISP programmer. In other words, there is no way around the programmer. <\/li>\n
- “Burning the bootloader” in the Arduino IDE is more than just uploading the bootloader to the program memory. It also sets the so-called fuses, which determine the clock speed and clock source, among other things.\n
- \n
- Therefore: When changing basic settings, it is also necessary to burn the bootloader if you want to upload programs via ISP. <\/li>\n<\/ul>\n<\/li>\n
- If you upload a program via ISP, any existing bootloader will be deleted.<\/li>\n<\/ul>\n
So, no matter which board or microcontroller you want to use with MiniCore, and no matter whether with bootloader or not: First you have to burn the bootloader.<\/strong><\/p>\n
The good news is: you can turn an Arduino board into an ISP programmer. The bad news is that the whole thing is quite fiddly and you can make mistakes in many places. I therefore recommend investing in a programmer. There are some available for just a few euros. Here<\/a> you can find a list of programmers that I successfully tried out in my last post. <\/p>\n\n
Burning the bootloader with an “Arduino as ISP”<\/h3>\n
In the following, I will show you how to turn a classic Arduino Nano into an ISP programmer. This also works with an Arduino UNO R3 and many other Arduino boards. There are a few differences in the details of some boards. There’s an article<\/a> on this topic on the Arduino website that I definitely recommend reading. <\/p>\n
Step 1:<\/strong> You select the Arduino Nano (the programmer<\/strong>) as the board in the Arduino IDE and connect it to the PC. Also set the correct port. It\u2019s best to do this without connecting the Arduino to anything else.
Step 2<\/strong>: Go to File \u2192 Examples \u2192 Built-in examples, open the ArduinoISP sketch, and upload it.
Step 3<\/strong>: Connect the Arduino Nano to the ATtiny85 as follows (you don’t need the LED here yet):<\/p>\n\n![\""Arduino](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/07\/ardu_nano_as_programmer_for_attiny85-1024x623.png\")
<\/a>“Arduino as ISP” connected to an ATtiny85<\/figcaption><\/figure>\n If you are using a different ATtiny, find the MISO, MOSI, SCK, RESET, VCC and GND pins in the respective pinout diagram and wire it accordingly. <\/p>\n
Step 4<\/strong>: Now select the TinyCore package and apply the following settings for the ATtiny85 (your target<\/strong>):<\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/settings_burn_urboot_bootloader.png\")
<\/a>Settings for burning the bootloader via “Arduino as ISP”<\/figcaption><\/figure>\n If you want to upload your sketches later via USB-to-TTL adapter, select “Yes” as option for the bootloader.<\/p>\n
Step 5<\/strong>: Click on “Burn Bootloader”.<\/p>\n\n
Using external oscillators <\/h4>\n
If you want to use an external crystal, connect the ATtiny as shown below and select the corresponding option for “Clock” when burning the bootloader. With an additional LED, pin availability on ATtiny85 gets tight. You will have to share a pin with MISO, MOSI, or SCK. <\/p>\n\n
![\"Using](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/ardu_as_isp_attiny85_ext_crystal-1024x418.png\")
<\/a>Using “Arduino as ISP” for the ATtiny85 with an external crystal<\/figcaption><\/figure>\n\n Burning the bootloader with a dedicated programmer<\/h3>\n
As mentioned before, burning the bootloader and uploading sketches via ISP is much easier with a “real” programmer. <\/p>\n
The programmers have a 6-pin and\/or 10-pin connector:<\/p>\n\n
\n\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/03\/isp_6pol_10pol-1024x362.png\")
<\/a>Pin assignment of the ISP outputs (sockets!)<\/figcaption><\/figure>\n<\/div>\n\n\n\n <\/div>\n<\/div>\nConnect the pins to their counterparts on the ATtiny. <\/p>\n
As you can easily get confused with the pins, I recommend using an adapter for breadboard circuits:<\/p>\n\n
\n\n![\"Using](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/attiny85_breadboard_adapter_isp.png\")
<\/a>Using an ISP breadboard adapter<\/figcaption><\/figure>\n<\/div>\n\n\n\n <\/div>\n<\/div>\nIn the above instructions for burning the bootloader, start with step 4 and set the correct programmer. For some programmers you have to select the correct port, other programmers do not appear under “Port” in “Tools”. You will need to install a driver for most programmers. You can read<\/a> more about this topic in my last post. <\/p>\n\n
Uploading sketches<\/h2>\n\n
Uploading sketches via ISP<\/h3>\n
Uploading via ISP is straightforward. Leave both the ATtiny connection and the settings in the Arduino IDE as they were when you burned the bootloader. Start the upload using the keyboard shortcut CTRL\/Shift\/U or via Sketch \u2192 “Upload with Programmer”. It also worked for me using the “normal” upload method (i.e. the arrow icon or Ctrl+U), but I can’t guarantee that it will work that way with every programmer. <\/p>\n
A blink sketch is suitable for testing. This will also show you whether everything is OK with the clock settings. <\/p>\n<\/p>\n
void setup() {\n \/\/ Serial.begin(9600);\n pinMode(PB4, OUTPUT);\n}\n\nvoid loop() {\n digitalWrite(PB4, HIGH); \/\/ PB4 or 4 or A2\n delay(1000); \n digitalWrite(PB4, LOW); \n delay(1000); \n \/\/ Serial.println(\"Hello World\");\n}<\/pre>\n\n
The advantage of the ISP method is that it saves the space in the flash memory that the bootloader would occupy.r. The Urboot bootloader used by TinyCore is already relatively slim with its 256 bytes, but that is still one-eighth of the ATtiny2xx<\/em>\u2019s program memory. The downside, however, is that you usually cannot connect to the serial monitor via the ISP port (a workaround for “Arduino as ISP” is explained below<\/a>). If you uncomment lines 2 and 11, you won\u2019t see any output. <\/p>\n
And don’t forget: Uploading a sketch via ISP overwrites any existing bootloader.<\/p>\n\n
Uploading sketches with a USB-to-TTL adapter<\/h3>\n
First, you\u2019ll need a USB-to-TTL adapter to upload your sketches; these are available for just a few euros. I recommend models that have a DTR pin. In theory, you can manage without one, but it\u2019s inconvenient. In my last post<\/a>, I wrote a bit more about the adapters. <\/p>\n\n
![\"Various](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/03\/usb_zu_ttl_adapter-1024x492.webp\")
<\/a>Various USB-to-TTL adapters<\/figcaption><\/figure>\n\n A prerequisite for uploading via USB-to-TTL adapter is the presence of the bootloader on your ATtiny. You cannot burn the bootloader with the USB-to-TTL adapter, but only with a programmer and the procedure described above. Select the option “Bootloader: Yes”. Once this is done, connect the USB-to-TTL adapter to the ATtiny as follows: <\/p>\n\n
![\"USB-to-TTL](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/usb_2_ttl_attiny85-1024x337.png\")
<\/a>USB-to-TTL adapter on the ATtiny85<\/figcaption><\/figure>\n\n 100 nF is generally recommended for the capacitor on the reset pin. If you don’t have one, you can try a larger one. For me it also worked with 10 \u00b5F. <\/p>\n
If you don’t have a DTR pin, leave out the capacitor and the pull-up resistor on Reset. When uploading, wait until the message “Warning: Attempt x of 10: not in sync” appears and then briefly pull the reset pin to GND. <\/p>\n
The USB-to-TTL adapter allows you to output to the serial monitor. To test this, uncomment lines 2 and 11 in blink_serial_test.ino. <\/p>\n\n
Uploading via ISP and using the serial monitor<\/h3>\n
Of course, you can also upload your sketches via ISP and use the serial monitor with an additional USB-to-TTL adapter. You only need to connect the GND, RX and TX pins of the USB-to-TTL adapter. You connect VCC if the ATtiny is not already supplied with power via the programmer. I was able to connect the programmer and adapter at the same time without any problems. When switching between uploading and serial output, you must select the correct ports. <\/p>\n\n
Saving SRAM <\/h4>\n
If you only want to output to the serial monitor but not send anything from it, you can select the “TX only” option under Serial in the settings. This saves 36 bytes of SRAM, which would otherwise be reserved for the RX buffer. And if you have enough flash, use the F macro:
Serial.print(F(\"......\"));<\/code>. <\/p>\n\nChanging the TX pin<\/h4>\n
You can assign TX to another pin using
Serial.setTxBit(PBn);<\/code>. Call this function before<\/em>Serial.begin()<\/code>. However, this is irrelevant for the program upload. For this step, TX is on the preset pin. After the upload, you can reconnect TX. <\/p>\n\nUsing the serial monitor via “Arduino as ISP”<\/h4>\n
I am not a fan of “Arduino as ISP”, but I would still like to show you a variant of this method that also allows you to use the serial monitor. The programmer uses SoftwareSerial. <\/p>\n
I found this variant here<\/a> in the German Arduino forum. First you have to download the modified version of the ArduinoISP sketch from there (alternatively, here<\/a> from GitHub). The SoftwareSerial communication requires an additional data line. The RX of the programmer (i.e. the Arduino board) is preset to pin D4. You can change this in the first lines of the modified ArduinoISP sketch. TX of the programmer is preset to the virtual pin 99. If you want to send messages from the serial monitor to the target (the ATtiny), you must change this to a real pin and set up a data line. <\/p>\n
Please note that the serial baud rate of the programmer is preset to 19200 baud<\/strong>. You must set this baud rate in the serial monitor, or you can change the default setting in the ArduinoISP sketch to
setup()<\/code>. <\/p>\nAnd this is what a test sketch for your ATtiny could look like: <\/p>\n<\/p>\n
#include<SoftwareSerial.h>\nSoftwareSerial softSerial(99, 4); \/\/ RX, TX - we don't need RX\n\nvoid setup() {\n softSerial.begin(9600); \/\/ set Baud 19200 in Serial Monitor!!!\n pinMode(PB3, OUTPUT);\n}\n\nvoid loop() {\n digitalWrite(PB3, HIGH); \n delay(1000); \n digitalWrite(PB3, LOW); \n delay(1000); \n softSerial.println(\"Hello World\");\n}<\/pre>\n\u00a0<\/p>\n
\n
Note that RX<\/em> is preset to the virtual pin 99 here.<\/p>\n
The disadvantage of this method is a slightly higher consumption of SRAM for the RX and TX buffers. There is also a small additional consumption of flash memory. <\/p>\n\n
Micronucleus Bootloader \u2013 Let us build a Digispark<\/h2>\n
The Micronucleus is a bootloader used on the Digispark<\/a> (ATtiny85) and MH-Tiny (ATtiny88) boards. Thereby the ATtiny is programmed directly via USB without adapter. To make this possible, the Micronucleus uses a technique called VUSB. This means that components that do not have a hardware USB interface can also be addressed via USB.<\/p>\n
The Digispark could once be integrated into the Arduino IDE using its own board package. Extensive documentation was available on the Digistump website. After that documentation was no longer available, users could continue working with Spence Konde\u2019s ATtinyCore. However, that approach no longer works either. So it\u2019s great news that TinyCore has integrated the Micronucleus bootloader. <\/p>\n
The downside of the Micronucleus \u2014 just like with the Urboot bootloader \u2014 is that it reduces the amount of available flash memory. Unfortunately, the Micronucleus requires even more memory, specifically about 1,400 bytes. <\/p>\n\n
Preparations<\/h3>\n\n
Burning the Micronucleus Bootloader<\/h4>\n
Of course, you can use commercially available Digispark or MH-Tiny boards. But I\u2019d also like to show you how to build a Digispark yourself. <\/p>\n
If you are not using a pre-assembled board, you must first burn the Micronucleus bootloader via ISP using a programmer. To do this, select “Micronucleus (16 MHz PLL)” as the bootloader. Alternative clock speeds are not supported. <\/p>\n\n
Circuit for the DIY Digispark<\/h4>\n
In addition to the ATtiny85, you will need two 68 \u03a9 resistors, one 1.5 k\u03a9 resistor, and two 3.6-volt Zener diodes for the circuit. The Zener diodes are used to protect the USB interface of your computer because the data lines use 3.3 volts. So be careful what you do!<\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/05\/attiny85_digispark_wiring-1024x607.png\")
<\/a>Circuit for the DIY Digispark<\/figcaption><\/figure>\n For the USB connection, I recommend using a USB breakout module. Here’s what the circuit looked like on the breadboard (with an additional LED on PB4): <\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/05\/attiny85_as_digispark-1024x666.jpg\")
<\/a>DIY Digispark on a breadboard<\/figcaption><\/figure>\n\n Upgrading the Micronucleus bootloader<\/h4>\n
There is an improved version of the Micronucleus bootloader, but you cannot burn it directly via ISP. Instead, first burn the standard version as described above, and then follow these steps: <\/p>\n
- \n
- Set the bootloader to: “Upgrade to the latest Micronucleus (16 MHz PLL)”. <\/li>\n
- If your Digispark or DIY project is still connected to the PC, disconnect it.<\/li>\n
- Select Tools \u2192 “Burn Bootloader”.<\/li>\n
- You see the error message \u201cError: no device found, waiting 60 seconds for the device to be plugged in …\u201d.<\/li>\n
- Connect the (DIY) Digispark to the PC via USB within 60 seconds (not via ISP!).<\/li>\n<\/ul>\n
Then the bootloader should be updated. <\/p>\n\n
Driver issues?<\/h4>\n
If the bootloader upgrade or later the upload of sketches doesn’t work, it might be due to the driver. I had problems with this at first, anyway. If you’re using Windows, connect your Digispark to the PC and go to Device Manager. There, the Digispark should appear under “libusb-win32 Devices” as “Digispark Bootloader.” Double-click the entry, go to Driver \u2192 Driver Details. If something other than libusb0 (Version >= 1.4.0.0) is listed there, you can use Zadig to set this driver. I\u2019ve described how to use Zadig here<\/a>. <\/p>\n\n
Uploading sketches<\/h3>\n
Disconnect the Digispark from the PC. Then click the upload arrow or use the keyboard shortcut “Ctrl+U.” You’ll see the error message again stating that no device was found. When you connect the Digispark to the PC via USB, the upload will start automatically. <\/p>\n\n
Further features of the TinyCore board package<\/h2>\n
Actually, this was only the beginning, because up to now the article was only about basic settings and the program upload. I have already gone into a little detail about Serial, but not about I2C and SPI. Other important topics are Timer\/PWM, the ADC, the EEPROM and Servo or Tone. The members of the classic ATtiny family differ quite significantly in terms of these functions. However, it would go beyond the scope of this article to go into this in detail. <\/p>\n
The good news: TinyCore abstracts many of the functions. For example, in most cases you will not even notice whether an ATtiny has a “real” UART or I2C interface or not. TinyCore is also excellently documented. On GitHub you will not only find general information on the functions mentioned, but also detailed descriptions of the individual members of the ATtiny family. The numerous example sketches provided are also particularly helpful. <\/p>\n
Other special features of the TinyCore package that I would like to point out are:<\/p>\n
- Uploading sketches with a USB-to-TTL adapter<\/a><\/li>\n
- Burning the bootloader with a dedicated programmer<\/a><\/li>\n<\/ul>\n<\/li>\n
- Pinout \/ Pinmapping<\/a><\/li>\n