Return to Answer

I recently wanted to do exactly this. Since there is no nice way to do so, I wound up writing a patch for the Stino sublime-text arduino plugin to do exactly this. It's subsequently been accepted, so it should be in any up-to-date Stino installs.

This adds a new option to Stino:

enter image description here

Using this mode produces compilation results like the following:

For a Uno:

Binary sketch size: 172 bytes (of a 32256 byte maximum, 0.53 percent).
Estimated memory use: 0 bytes (of a 1024 byte maximum, 0.00 percent).

For a leonardo

Binary sketch size: 240 bytes (of a 28672 byte maximum, 0.84 percent).
Estimated memory use: 0 bytes (of a 2560 byte maximum, 0.00 percent).

_{Actually programming the leonardo with the above compiled output is probably a bad idea, as it might break the auto-reset functionality, but you could, if you wanted. Hat-tip to mpflaga for noting this in his answer.}

Note that the memory reports are actually incorrect, but that's a separate issue.

The code used for the above is:

int main()
{
 while (1)
 {
 }
}

Some notes:

• You ain't writing a "Sketch" anymore, not that you ever actually do write a sketch. You write programs. Period. I don't care what the Arduino wackos want to say, they don't get to redefine terms.
• All interrupt management is manual. This means no milis() or similar.
• You can still use the arduino serial libraries and so forth, if you want. You do have to #include <Arduino.h>.
• You define main. You don't ever return from main. If you want setup stuff, it goes before the while (1).
• If you're still using the arduino-shty-flaming-pile-of-st editor/two-macro-buttons thing, you should switch. Have you tried Stino ? Or ANYTHING else? Hell, even Eclipse is better (and that doesn't get said often).

I recently wanted to do exactly this. Since there is no nice way to do so, I wound up writing a patch for the Stino sublime-text arduino plugin to do exactly this. It's subsequently been accepted, so it should be in any up-to-date Stino installs.

This adds a new option to Stino:

enter image description here

Using this mode produces compilation results like the following:

For a Uno:

Binary sketch size: 172 bytes (of a 32256 byte maximum, 0.53 percent).
Estimated memory use: 0 bytes (of a 1024 byte maximum, 0.00 percent).

For a leonardo

Binary sketch size: 240 bytes (of a 28672 byte maximum, 0.84 percent).
Estimated memory use: 0 bytes (of a 2560 byte maximum, 0.00 percent).

_{Actually programming the leonardo with the above compiled output is probably a bad idea, as it might break the auto-reset functionality, but you could, if you wanted. Hat-tip to mpflaga for noting this in his answer.}

Note that the memory reports are actually incorrect, but that's a separate issue.

The code used for the above is:

int main()
{
 while (1)
 {
 }
}

Some notes:

• You ain't writing a "Sketch" anymore, not that you ever actually do write a sketch. You write programs. Period. I don't care what the Arduino wackos want to say, they don't get to redefine terms.
• All interrupt management is manual. This means no milis() or similar.
• You can still use the arduino serial libraries and so forth, if you want. You do have to #include <Arduino.h>.
• You define main. You don't ever return from main. If you want setup stuff, it goes before the while (1).

I recently wanted to do exactly this. Since there is no nice way to do so, I wound up writing a patch for the Stino sublime-text arduino plugin to do exactly this. It's subsequently been accepted, so it should be in any up-to-date Stino installs.

This adds a new option to Stino:

enter image description here

Using this mode produces compilation results like the following:

For a Uno:

Binary sketch size: 172 bytes (of a 32256 byte maximum, 0.53 percent).
Estimated memory use: 0 bytes (of a 1024 byte maximum, 0.00 percent).

For a leonardo

Binary sketch size: 240 bytes (of a 28672 byte maximum, 0.84 percent).
Estimated memory use: 0 bytes (of a 2560 byte maximum, 0.00 percent).

_{Actually programming the leonardo with the above compiled output is probably a bad idea, as it might break the auto-reset functionality, but you could, if you wanted. Hat-tip to mpflaga for noting this in his answer.}

Note that the memory reports are actually incorrect, but that's a separate issue.

The code used for the above is:

int main()
{
 while (1)
 {
 }
}

Some notes:

• You ain't writing a "Sketch" anymore, not that you ever actually do write a sketch. You write programs. Period. I don't care what the Arduino wackos want to say, they don't get to redefine terms.
• All interrupt management is manual. This means no milis() or similar.
• You can still use the arduino serial libraries and so forth, if you want. You do have to #include <Arduino.h>.
• You define main. You don't ever return from main. If you want setup stuff, it goes before the while (1).
• If you're still using the arduino-shitty-flaming-pile-of-shit editor/two-macro-buttons thing, you should switch. Have you tried Stino? Or ANYTHING else? Hell, even Eclipse is better (and that doesn't get said often).

I recently wanted to do exactly this. Since there is no nice way to do so, I wound up writing a patch for the Stino sublime-text arduino plugin to do exactly this. It's subsequently been accepted, so it should be in any up-to-date Stino installs.

This adds a new option to Stino:

enter image description here

Using this mode produces compilation results like the following:

For a Uno:

Binary sketch size: 172 bytes (of a 32256 byte maximum, 0.53 percent).
Estimated memory use: 0 bytes (of a 1024 byte maximum, 0.00 percent).

For a leonardo

Binary sketch size: 240 bytes (of a 28672 byte maximum, 0.84 percent).
Estimated memory use: 0 bytes (of a 2560 byte maximum, 0.00 percent).

_{Actually programming the leonardo with the above compiled output is probably a bad idea, as it might break the auto-reset functionality, but you could, if you wanted. Hat-tip to mpflaga for noting this in his answer.}

Note that the memory reports are actually incorrect, but that's a separate issue.

The code used for the above is:

int main()
{
 while (1)
 {
 }
}

Some notes:

• You ain't writing a "Sketch" anymore, not that you ever actually do write a sketch. You write programs. Period. I don't care what the Arduino wackos want to say, they don't get to redefine terms.
• All interrupt management is manual. This means no milis() or similar.
• You can still use the arduino serial libraries and so forth, if you want. You do have to #include <Arduino.h>.
• You define main. You don't ever return from main. If you want setup stuff, it goes before the while (1).
• If you're still using the arduino-shty-flaming-pile-of-st editor/two-macro-buttons thing, you should switch. Have you tried Stino? Or ANYTHING else? Hell, even Eclipse is better (and that doesn't get said often).

I recently wanted to do exactly this. Since there is no nice way to do so, I wound up writing a patch for the Stino sublime-text arduino plugin to do exactly this. It's subsequently been accepted, so it should be in any up-to-date Stino installs.

This adds a new option to Stino:

enter image description here

Using this mode produces compilation results like the following:

For a Uno:

Binary sketch size: 172 bytes (of a 32256 byte maximum, 0.53 percent).
Estimated memory use: 0 bytes (of a 1024 byte maximum, 0.00 percent).

For a leonardo

Binary sketch size: 240 bytes (of a 28672 byte maximum, 0.84 percent).
Estimated memory use: 0 bytes (of a 2560 byte maximum, 0.00 percent).

_{Actually programming the leonardo with the above compiled output is probably a bad idea, as it might break the auto-reset functionality, but you could, if you wanted. Hat-tip to mpflaga for noting this in his answer.}

Note that the memory reports are actually incorrect, but that's a separate issue.

The code used for the above is:

int main()
{
 while (1)
 {
 }
}

Some notes:

• You ain't writing a "Sketch" anymore, not that you ever actually do write a sketch. You write programs. Period. I don't care what the Arduino wackos want to say, they don't get to redefine terms.
• All interrupt management is manual. This means no milis() or similar.
• You can still use the arduino serial libraries and so forth, if you want. You do have to #include <Arduino.h>.
• You define main. You don't ever return from main. If you want setup stuff, it goes before the while (1).

I recently wanted to do exactly this. Since there is no nice way to do so, I wound up writing a patch for the Stino sublime-text arduino plugin to do exactly this. It's subsequently been accepted, so it should be in any up-to-date Stino installs.

This adds a new option to Stino:

enter image description here

Using this mode produces compilation results like the following:

For a Uno:

Binary sketch size: 172 bytes (of a 32256 byte maximum, 0.53 percent).
Estimated memory use: 0 bytes (of a 1024 byte maximum, 0.00 percent).

For a leonardo

Binary sketch size: 240 bytes (of a 28672 byte maximum, 0.84 percent).
Estimated memory use: 0 bytes (of a 2560 byte maximum, 0.00 percent).

_{Actually programming the leonardo with the above compiled output is probably a bad idea, as it might break the auto-reset functionality, but you could, if you wanted. Hat-tip to mpflaga for noting this in his answer.}

Note that the memory reports are actually incorrect, but that's a separate issue.

The code used for the above is:

int main()
{
 while (1)
 {
 }
}

Some notes:

• You ain't writing a "Sketch" anymore, not that you ever actually do write a sketch. You write programs. Period. I don't care what the Arduino wackos want to say, they don't get to redefine terms.
• All interrupt management is manual. This means no milis() or similar.
• You can still use the arduino serial libraries and so forth, if you want. You do have to #include <Arduino.h>.
• You define main. You don't ever return from main. If you want setup stuff, it goes before the while (1).
• If you're still using the arduino-shitty-flaming-pile-of-shit editor/two-macro-buttons thing, you should switch. Have you tried Stino ? Or ANYTHING else? Hell, even Eclipse is better (and that doesn't get said often).