TinyCore is based on ATtinyCore and comes with some improvements. The disadvantage is that TinyCore does not (yet?) support Digispark\/Micronucleus boards, but this is the only drawback I have found so far. <\/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
- 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
![\"Selected](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2026\/05\/attiny_properties-1024x587.png\")
<\/a>Selected properties of the classic ATtinys<\/figcaption><\/figure>\n Although the ATtinys may seem a bit outdated due to their sometimes very limited RAM and flash memory, they remain very popular. From a technical point of view, the newer models of the tinyAVR\u00ae 0 to 3 series are almost always the better choice (article here<\/a>). However, the classic ATtinys are favored by their enormous popularity and the associated high number of articles, tutorials, and forum posts. In addition, they are available as PDIP and have a relatively simple and therefore easy-to-understand architecture. In my opinion, they are definitely still worth their own article. <\/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 means more than just uploading the bootloader to the flash. You also set the so-called fuses, which determine the clock rate and the 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
Sketch upload via ISP is simple. Leave both the connection of the ATtiny and the settings in the Arduino IDE as they were when burning the bootloader. You start the upload via the keyboard shortcut CTRL\/Shift\/U or via Sketch \u2192 “Upload with Programmer”. It also worked for me with the “normal” upload (i.e., arrow symbol or CTRL\/U), but I cannot guarantee that this will work 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 you save the space for the bootloader in the flash. The Urboot bootloader used by TinyCore is comparatively slim at 256 bytes, but that is still an eighth of the program memory of the ATtiny2xx<\/em>. The disadvantage is that you usually have no connection to the serial monitor via the ISP connection (a trick for the “Arduino as ISP” is described below<\/a>). If you uncomment lines 2 and 11, you will not 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 of all, you need a USB-to-TTL adapter for uploading, which is available for a few euros. I recommend variants that have a DTR pin. In principle, you can do without one, but it’s inconvenient. I wrote a bit more about the adapters in my last post<\/a>. <\/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\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
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