[Question]
  [
Today is November 8th, 2016, [Election Day](https://en.wikipedia.org/wiki/Election_Day_(United_States)) in the United States of America.
If you are a U.S. citizen eligible to vote, then [go out and vote](https://www.google.com/#q=where+do+i+vote) if you haven't already before answering this challenge. **Do not discuss who you voted for.** It only matters that you voted.
If you are not a U.S. citizen or not eligible to vote, then, before answering this challenge, do the U.S. a favor by telling anyone you know who is an eligible citizen to [go out and vote](https://www.google.com/#q=where+do+i+vote) if they haven't already.
# Challenge
Write a program that indicates that you voted, like a digital ["I Voted" sticker](https://commons.wikimedia.org/wiki/File:I_Voted_Sticker.JPG).
It should take no input and must output in a reasonable way the phrase `I Voted` where the `I`, `o`, and `e` are red (`#FF0000`) and the `V`, `t`, and `d` are blue (`#0000FF`). The background must be white (`#FFFFFF`).
For example:
> 
> [!["I Voted" example graphic](https://i.stack.imgur.com/sbIcI.png)](https://i.stack.imgur.com/sbIcI.png)
> 
> 
> 
These colors are of course representative of the [American flag](https://en.wikipedia.org/wiki/Flag_of_the_United_States) (though not [the official colors](https://en.wikipedia.org/wiki/Flag_of_the_United_States#Colors)). Red comes first simply because it comes first in the common idiom "red white and blue".
To be valid, an answer must:
* Use the colors specified in the arrangement specified.
* Use a single legible font and font size. The example uses 72pt Times New Roman bold but any common font above 6pt is probably fine.
* Have just the phrase `I Voted` on a **single line**, capitalized correctly, with a clear space between the two words. It shouldn't look like `IVoted`.
* Not indicate who the answerer voted for or supports for president or any down-ballot races. Let's not start any internet debates. This is about celebrating voting, not candidates.
Any reasonable way of displaying or producing the output is valid, such as:
* Drawing the text to an image that is then displayed, saved, or output raw.
* Writing the text to a console using [color formatting](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors). In this case you may approximate pure red and blue if necessary, and it's ok if only the area directly behind the text can be made white.
* Displaying the text on a WPF/Windows form.
* Outputting an HTML/RTF/PDF file with the text.
Please post an image of your output.
**The shortest answer in bytes wins.**
  
[Answer]
##  Minecraft Chat (vanilla 1.10 client, spigot 1.10 server): 19 bytes
```
&4I &1V&4o&1t&4e&1d
```
or from the clientside:
```
§4I §1V§4o§1t§4e§1d
```
Minecraft uses a color coding system with these colors programmed in.
[![enter image description here](https://i.stack.imgur.com/Kd7Xr.png)](https://i.stack.imgur.com/Kd7Xr.png)
Mind the rules: 
> 
> * Writing the text to a console using color formatting. In this case you may approximate pure red and blue if necessary, and it's ok if only the area directly behind the text can be made white.
> 
> 
> 
All of these are true, as:  
the red and blue ARE approximations (though still very similar).  
The background in Minecraft chat is transparent, meaning that it's possible to put this on a white background (such as an empty world or a world which is still generating).
[Answer]
# C, ~~82~~ ~~80~~ ~~78~~ ~~74~~ 54 bytes
*Thanks to @WillihamTotland and @criptych for saving 2 bytes each!*
```
f(){puts("␛[47;31mI␛[34m V␛[31mo␛[34mt␛[31me␛[34md");}
```
Where the ␛s represent 0x1B bytes (escape key). As this code contains unprintable control characters, here is a reversible hexdump:
```
00000000: 6628 297b 7075 7473 2822 1b5b 3437 3b33  f(){puts(".[47;3
00000010: 316d 491b 5b33 346d 2056 1b5b 3331 6d6f  1mI.[34m V.[31mo
00000020: 1b5b 3334 6d74 1b5b 3331 6d65 1b5b 3334  .[34mt.[31me.[34
00000030: 6d64 2229 3b7d                           md");}
```
Output on my phone:
![](https://i.stack.imgur.com/BaDos.jpg)
[Answer]
# [Google Blockly](https://blockly-games.appspot.com/turtle), ~~10~~ 14 blocks, ~~28~~ ~~41~~ 35 blytes
### Code
[![enter image description here](https://i.stack.imgur.com/omGDX.png)](https://i.stack.imgur.com/omGDX.png)
### Output
[![enter image description here](https://i.stack.imgur.com/BhtRv.png)](https://i.stack.imgur.com/BhtRv.png)
[Try it here](https://blockly-games.appspot.com/turtle?lang=en&level=10#ncejg6)
Not counting the `hide turtle` block because it's just aesthetics.
A blyte is a combination of a block and a byte, there's no meta post yet as how to count this, but I'll create one later. As for now, this is how I count: 
* `I o e`, 8 blytes
* `V t d`, 10 blytes (2 leading spaces here)
* Colours, 1 blyte each, 2 total
* 90, 2 blytes
* 999, 3 blytes
* 0, 1 blyte
* turn right, 2 blytes
* move forward, 2 blytes
* normal blocks, 1 blyte each, 5 total
Since Google Blockly is rarely used for golfing and I'm thinking waaay outside of the box for this challenge, I hope this is a valid submission.
[Answer]
# HTML, 52 bytes
```
I <c>V<e>o<c>t<e>e<c>d<style>*{color:red}c{color:0ff
```
[Answer]
# LaTeX, ~~147~~ 126 bytes
```
\documentclass{proc}\input color\begin{document}\def\z{\color{red}}\def\y{\color{blue}}\z I \y V\z o\y t\z e\y d\end{document}
```
*Saved 21 bytes and got better kerning thanks to @AndreïKostyrka.*
This prints an a4 page with this on the first line (note that this also prints page 1 on the bottom):
[![enter image description here](https://i.stack.imgur.com/TtdsT.png)](https://i.stack.imgur.com/TtdsT.png)
[Answer]
## Windows 10 Batch, ~~51~~ 50 bytes
```
@color fc&echo I ␛[94mV␛[91mo␛[94mt␛[91me␛[94md␛[m
```
Where ␛ represents the ANSI Escape 0x1B character. Outputs using colour formatting. Edit: Saved 1 byte thanks to @brianush1. I tried writing the code to generate this but it took 97 bytes. Output:
![I voted](https://i.stack.imgur.com/Jn244.png)
[Answer]
# JavaScript, 71 bytes
```
console.log('%cI %cV%co%ct%ce%cd',r='color:red',b='color:blue',r,b,r,b)
```
Makes use of `console.log`'s ability to print in color. Doesn't work in a stack snippet so you should paste this answer to the console to test it.
[![enter image description here](https://i.stack.imgur.com/Z2UBW.png)](https://i.stack.imgur.com/Z2UBW.png)
Picture credits to @Mast
[Answer]
# R, 113 85 81 74 73 55 bytes
Edit: Saved a bunch of bytes thanks to @rturnbull and @JDL
```
plot(8:1,0:7*0,pc=el(strsplit("detoV  I","")),co=2:1*2)
```
The size of the output (and spacing etc) depends on the resolution of the currently open graphics device. Tested in RGui and RStudio on my monitor and produces:
[![enter image description here](https://i.stack.imgur.com/gslLl.png)](https://i.stack.imgur.com/gslLl.png)
[Answer]
## [LÖVE](https://love2d.org/), ~~152 142~~ 136 bytes
Let's show some löve for a fun little prototyping language! It's not perfect for the task of golfing (c'mon, it's LUA based), but it's easy to write.
```
function love.draw()l=love.graphics
a=255
l.setBackgroundColor(a,a,a)s=l.setColor
p=l.print
s(a,0,0)p('I   o e')s(0,0,a)p('  V  t d')end
```
---
Screenshot:
[![screenshot](https://i.stack.imgur.com/VPG2A.png)](https://i.stack.imgur.com/VPG2A.png)
---
Fully ungolfed version:
```
function love.draw()
    love.graphics.setBackgroundColor(255,255,255)
    love.graphics.setColor(255,0,0)
    love.graphics.print('I   o e')
    love.graphics.setColor(0,0,255)
    love.graphics.print('  V  t d')
end
```
[Answer]
## [Hot Soup Processor](https://en.wikipedia.org/wiki/Hot_Soup_Processor), 48 bytes
```
color 255
mes"I  o e
pos,0
color,,-1
mes"  V t d
```
The ungolfed version is:
```
color 255,0,0
mes "I  o e"
pos 0,0
color 0,0,255
mes "  V t d"
```
If you bear in mind that `mes` (message) is HSP's `echo`, I think this is fairly readable.
Weirdly, if you try to do `pos` or `pos,`, the blue line doesn't overwrite the red line and appears beneath it. Even weirder, `color` is only meant to take values in `0-255`, but `0,0,-1` works for blue, `0,-1,0` works for green and `-1,0,0` works for... black? (`-257,0,0` and `511,0,0` work for red though, so something's funky about the mod 256 going on)
[![enter image description here](https://i.stack.imgur.com/sfcHem.png)](https://i.stack.imgur.com/sfcHem.png)
[Answer]
## MATLAB, 74 bytes
We create a white 50x50 (one column for each state) background using `imshow` of an array of `ones`. We then display a text, using my [trick of shortening property names](https://codegolf.stackexchange.com/a/48268/32352) to get the colours. Since the default font is not fixed width, the text is padded with spaces.
```
imshow(ones(50))
text(2,9,'I   o e','Co','r')
text(8,9,'V  t  d','Co','b')
```
[![enter image description here](https://i.stack.imgur.com/EBgGh.png)](https://i.stack.imgur.com/EBgGh.png)
### MATLAB, 99 bytes, fixed width font
The first version uses fiddling with spaces and coordinates to get a proper kerning on the default font, and might not display properly on your computer. Instead, we can use a fixed width font, like `Courier` (or, for some more bytes, `FixedWidth` which works on any system that has a fixed width font installed). This does come at the cost of quite a few extra bytes. We can mitigate this slightly by using a `for` loop to print the text. The text and corresponding colours are stored in a cell array. The background needs to be a little bit larger.
```
imshow(ones(80))
for y={'I  o e ','  V t d';'r','b'}
text(9,9,y{1},'Co',y{2},'FontN','Courier')
end
```
[![enter image description here](https://i.stack.imgur.com/eOcWQ.png)](https://i.stack.imgur.com/eOcWQ.png)
### Matlab, 80 bytes bonus edition
Sadly, underlined blue text is not allowed. Otherwise, this answer would have highlighted some interesting behaviour in MATLAB. You can print red text using `fprintf(2,txt)`, and you can print blue underlined text with `fprintf('<a href="">txt</a>')`. Combining this works... sometimes. **Completely at random**, it may also create red underlined text. You can issue `drawnow` between consecutive `f` calls if this is the case on your system.
```
f=@(p)fprintf(2,'%s<a href>%s</a>',p(1:end-1),p(end));f('I V');f('ot');f('ed');fprintf('\n')
```
[![enter image description here](https://i.stack.imgur.com/gSa9q.png)](https://i.stack.imgur.com/gSa9q.png)
[Answer]
# ImageMagick, 102 bytes
```
magick xc:[x60] -fill red -draw 'text 5,30 "I     o  e"' -fill blue -draw 'text 15,30 "V   t   d"' x:
```
Ungolfed:
```
magick convert canvas:white[60x60!] \
       -fill red  -draw 'text 5,30   "I     o  e"' \
       -fill blue -draw 'text 15,30      "V   t   d"' \
       show:
```
[![enter image description here](https://i.stack.imgur.com/1AZfV.png)](https://i.stack.imgur.com/1AZfV.png)
Golfing the full ImageMagick command consisted of
* not explicitly calling the default `convert` utility
* using `xc:` instead of `canvas:` (`xc:` is an old synonym for `canvas:`; I don't foresee ImageMagick ever eliminating it)
* not specifying the canvas color but relying on ImageMagick's default, which happens to be white
* removing the width `60` from the geometry (when it's omitted, width==height)
* removing the "!" from the geometry which is only needed to produce a non-square canvas, like `canvas:white[60x30!]`
* using the older `x:` instead of `show:` as the output file (assumes that ImageMagick was built with `X` support)
* removing some whitespace that I had used to line up the text strings
* joining the multiple lines of the command (removed the backslash-CR between lines)
If you are so inclined after the election, add 12 bytes `-rotate 180` preceding the `show:` directive:
[![enter image description here](https://i.stack.imgur.com/5F2uJ.png)](https://i.stack.imgur.com/5F2uJ.png)
[Answer]
# Bash, 35 bytes
My script looks like this
```
echo "^[[47;31mI hope^[[34md^H^H^Ht^H^H^Hv"
```
xxd of script file:
```
0000000: 6563 686f 2022 1b5b 3437 3b33 316d 4920  echo ".[47;31mI 
0000010: 686f 7065 1b5b 3334 6d64 0808 0874 0808  hope.[34md...t..
0000020: 0876 22                                  .v"
```
Typing it: ctrl-v-esc and ctrl-v-h will insert the escapes and backspaces (^[ and ^H).
[![enter image description here](https://i.stack.imgur.com/Nd7Tz.png)](https://i.stack.imgur.com/Nd7Tz.png)
[Answer]
# Mathematica (REPL image output), ~~65~~ 49 bytes
```
Overlay@{"I  o e"~Style~Red,"  V t d"~Style~Blue}
```
Graphical REPL expression.
![](https://i.stack.imgur.com/dn9PK.png)
[Answer]
# Java, ~~322~~ ~~319~~ ~~318~~ ~~309~~ ~~304~~ ~~229~~ 217 bytes
-9 Bytes thanks to kevin.  
-75 Bytes thanks to Angzuril, nice callout on the old awt classes, always forget those exist.  
-12 Bytes thanks to user902383.
```
import java.awt.*;
void n(){new Frame(){{add(new Panel(){public void paint(Graphics g){int i=0;for(String c:"IVoted".split("")){g.setColor(i%2<1?Color.RED:Color.BLUE);g.drawString(c,i++*8,10);}}});setVisible(0<1);}};}
```
Output:
[![enter image description here](https://i.stack.imgur.com/KMMPm.png)](https://i.stack.imgur.com/KMMPm.png)
[Answer]
# Bubblegum, 28 bytes
```
0000000: 938e 3636 ccf5 0492 e6b9 0a40 d224 370c  ..66.......@.$7.
0000010: 2c92 0f66 9780 d9a9 6076 0a00            ,..f....`v..
```
[![enter image description here](https://i.stack.imgur.com/qGloV.png)](https://i.stack.imgur.com/qGloV.png)
Does not work online since it uses ANSI color codes for coloring.
[Answer]
## PowerShell v2+, ~~71~~ ~~59~~ ~~57~~ 55 bytes
```
"I Voted"[0..6]|%{Write-Host -b w -n -f (9,12)[$_%2]$_}
```
*Saved two bytes thanks to [@flashbang](https://codegolf.stackexchange.com/users/61224/flashbang) ... saved two more thanks to [@ConnorLSW](https://codegolf.stackexchange.com/users/59735/connorlsw)*
Takes `"I Voted"` and turns it into a `char`-array, then loops `|%{...}`. Each letter, we execute `Write-Host` with the `-b`ackground color to `White`, `-n`oNewLine, and the `-f`oreground color to be the [appropriate index](https://msdn.microsoft.com/en-us/library/system.consolecolor(v=vs.110).aspx). This leverages the fact that odd ASCII values are Red, while even ASCII values are Blue via `$_%2` as the index.
Console colors in PowerShell are *very* limited, so this is the closest approximation I could get. It would be golfier to use `4` (`DarkRed`) for the red, but it doesn't look right, so I'm sacrificing a couple bytes for the sake of color accuracy.
Below is the output, followed by the 16 available colors the console can display. Note that the background isn't *truly* white, since Microsoft in their wisdom opted to have the background colors ever-so-slightly-off from the foreground colors.
[![Console Output](https://i.stack.imgur.com/9w3Xr.png)](https://i.stack.imgur.com/9w3Xr.png)
[Answer]
# Python, 91 bytes + `termcolor`
Not gonna win, but posted it for fun.
```
from termcolor import*
for c in'I Voted':cprint(c,'brleude'[ord(c)%2::2],'on_white',end='')
```
Half the credit goes to Sp3000.
[Answer]
# Python IDLE, ~~97~~ ~~96~~ ~~78~~ 69 bytes
*Thanks to DrMcMoylex for shaving off some bytes!*
*EDIT: Figured out that a direct `.write()` was 9 bytes shorter*
Not really a proper answer, more abuse of a standard theme. IDLE is Python's IDE, and unless it's customized, `STDOUT` is blue, `STDERR` is red, and the background is white. So, the following code:
```
from sys import*
for i in'I Voted':[stdout,stderr][ord(i)%2].write(i)
```
Prints this:
[![enter image description here](https://i.stack.imgur.com/maWj1.png)](https://i.stack.imgur.com/maWj1.png)
This works because `ord(i)%2` checks the parity of the letter's code point and prints it to `ERR`/`OUT` accordingly.
[Answer]
# Jolf, 53 bytes
```
"<z>I <w>V<z>o<w>t<z>e<w>d<style>w{ΞΩ4blue}z{ΞΩ4red
```
There are unprintables. [Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=Ijx6PkkgPHc-Vjx6Pm88dz50PHo-ZTx3PmQ8c3R5bGU-d3vOnh3OqTRibHVlfXp7zp4dzqk0cmVk)
Jolf's output is HTML capable. I tried doing something clever like modulus 2 to decide color, but that only wound up longer (around 69 bytes). So, the output is in HTML. 
Output:
[![regular "I Voted"](https://i.stack.imgur.com/ygDZc.png)](https://i.stack.imgur.com/ygDZc.png)
(larger version)
[![large "I Voted"](https://i.stack.imgur.com/vZDLH.png)](https://i.stack.imgur.com/vZDLH.png)
[Answer]
# Python, ~~99~~ 87 bytes
```
from turtle import*
up()
for c in"I Voted":color("brleude"[ord(c)%2::2]);write(c);fd(7)
```
[**Try it online**](https://trinket.io/python/7b15195a1e)
[Answer]
# sh, ~~61~~ 49 bytes
```
echo "[47;31;1mI [34mV[31mo[34mt[31me[34md"
```
Because this contains unprintables, here is a reversible xxd hexdump:
```
00000000: 6563 686f 2022 1b5b 3437 3b33 313b 316d  echo ".[47;31;1m
00000010: 4920 1b5b 3334 6d56 1b5b 3331 6d6f 1b5b  I .[34mV.[31mo.[
00000020: 3334 6d74 1b5b 3331 6d65 1b5b 3334 6d64  34mt.[31me.[34md
00000030: 22                                       "
```
[![I Voted](https://i.stack.imgur.com/DVtzl.png)](https://i.stack.imgur.com/DVtzl.png)  
*Xterm(322)*
Thanks to 4198 (manatwork) for -12 bytes.
[Answer]
# SVG + `bzip2`, 1807 bytes
A vectorized version of the example image, then compressed with bzip2 to about half (4385 -> 1807 bytes). You can download it [here](https://crazypython.github.io/datadump/a.svg.bz2). (direct GitHub Pages link)
```
BZh91AY&SY!�l�ß�x��>�ߠ/���`    0����Ҁ�D�5��ޠII�T񡤙�O!45J??��i�@JzH���
.�M�&�Q�vا����bB���� �쾾�4AV�8�8���)Z�ޣ�j�q}�����?�t�/
�±%��"A����B�X�(␌�[⎺;Z/┐├*��%�␤�       I���Uƒ�Y�9ǝK���B��┤�=���±?�W���
            ��ڰj�?�H��\����^��m�=X�d���>�!C�@�.���9�" DZ+��V1+�;�����58Q���-:�5,HDQŧ`A>����W�+h��>m��G�m�uWv�&�U�|mq�u���?=S�\{(��Z�a�I��G{Cd��;Bz���qX7��?P�@�Jt[w�]����%W���37f���-񴁭�iԳ]c��|�;i�k�H��
    sHz��Y�$�.�*�?�ڐ��Us=\뫅6%�Ud�9w���D
                                          ��H��^�Q��P��%n�O����l��+*q�U�"F%��*�     *b�� 
                                         @mP���Z�(ZL`
  bIv⦳�~�F=��>H�Ti����0@≠R≥��T�E��┴��D����␍│��2*◆=└6&⎽M�◆␊?�/�U�����r�.�`gƅ���E'��^��ILPz@���zR&u$��l^�U�n�'O\�Xj+چ�o�*�O�w��JP8���]���r��k=��N�b�ƵpM�8|���=7���N��W�M(����*�E�DݐT��Zi�v"���49�J�0}�F�*x�K���P��⎼*�������6[G,4� ү)UUT␍��%4D��Թ␉��⎻�8�CZ_3ɷwW�9��-&�Ov�a՜
�'ӥtߢ�>��^�m-������c�]:��*��2��촄Ujr�?"�J�"���DE�f?┴⎻��␍3·└���Ԉ��? ׌�5|ᫎ���|DO���%�4Ư`W�ƐV/=�]V`gˇ��^Z��cP������.{������6   o.*�sɽ���U?E.3�,�H$�{�?
             �%�0��2    ��n�C!%�>��]��
#߽v�E��K��?X|���5�ΰ@>A;#J���,��Q��$���ݨ��^����7�g�Xn�k����d욒�`fQ/7��vh|�ȥ*^M
                            �[����׈���i�I��    $��4��
  Y��`V.��ح��?�eT����5K˱~�瞯r�fL^I �#b�@�pBƞ���V`5��a��qH���Ş�t�V3��┌���T���1␉�␍$5��@T␤$�>$����π���S�[۸£�[ȟ␋CO≥�ގ^��>��]E�A��┘���I(�㴨Z�J'��:�-_┤±�K␌�ۓ#:�?m��^�Z�+�����G
�k�t�O��SD�4����^o��Z�n���6M�)!��r��w�3\�R����
�X6<#����.��p� Cj"�2�ĭ�*h�S�`}�L���C?�� �چZc'kG��
```
Not gonna win, but posted it for fun.
[Answer]
## C, 65 bytes
```
i;main(c){for(;c="I Voted"[i++];printf("\33[3%dm%c",c&1?1:4,c));}
```
or, more accurately:
```
i;main(c){for(i=90;c="\0.noitcele ym saw ti fi enod evah dluow I sseug I tuB .hsitirB ma I esuaceb ,etov ton did I"[i--];printf("\33[3%dm%c",c&1?1:4,c));}
```
Uses the same bash colour technique used by betseg, but with the octal escape sequence instead of hex, and with Sp3000's observation that all odd codepoints are red.
Leaves the terminal in blue. Reset with:
```
printf "\33[0m";
```
[Answer]
# Node, ~~57~~ ~~55~~ 41 bytes
```
console.log("q47;91mI  o eHHHHq94mV t d")
```
Replace each `q` with the literal byte `1B` and `H` with byte `08` before running.
Here's how it looks in the ConEmu terminal emulator on my Windows computer (zoomed in):
[![enter image description here](https://i.stack.imgur.com/Nvvud.png)](https://i.stack.imgur.com/Nvvud.png)
[Answer]
## [REBOL](http://www.rebol.com/), ~~100~~ ~~90~~ 95 bytes (-7 bytes with REPL for 88)
```
REBOL[]view layout[style b tt blue white space 0 across b"I"red b b"V"b"o"red b"t"b"e"red b"d"]
```
In REPL, the initial *REBOL[]* is not required. That's 7 bytes.
The ungolfed version is:
```
REBOL[]
view layout[
  ; by default, tt (text) has a grey background and a 2x2 padding
  style b tt blue white space 0
  ; this one doesn't appear in the golfed version as it's slightly shorter to just manually set red everywhere needed
  style r b red
  ; by default, vertical stack panel
  across
  r "I"
  r 
  b "V"
  r "o"
  b "t"
  r "e"
  b "d"
]
```
On the left, with "space 0x0" added to each text block, on the right, with the default 2x2 padding.
[![REBOL I Voted](https://i.stack.imgur.com/ui76m.jpg)](https://i.stack.imgur.com/ui76m.jpg)  
(source: [canardpc.com](http://tof.canardpc.com/view/0fe86fe8-4eb8-4d38-9a21-db226b41bc7f.jpg)) 
[Answer]
# Perl, 57 + 17 = 74 bytes
Run with `-MTerm::ANSIColor`
```
sub c{color$a++%2?blue:red}say c,"I ",c,V,c,o,c,t,c,e,c,d
```
Your terminal may be blue at the end (append `,c("reset")` at the end of the code to restore it to normal).
By default, terminals are *usually* black background, but they can be optionally changed to white, which I personally don't think is cheating.
With picture:
[![enter image description here](https://i.stack.imgur.com/siklB.png)](https://i.stack.imgur.com/siklB.png)
[Answer]
# PHP, ~~199~~ ~~201~~ 151 bytes
This script outputs image to standard output. **Updated thanks to manatwork**
```
imagefill($i=imagecreatetruecolor(99,99),0,0,2**24-1);foreach([I,' ',V,o,t,e,d]as$k=>$e)imagestring($i,2,$k*9,0,$e,!$k|$k&1?0xFF0000:255);imagepng($i);
```
Run it in the command line like this:
```
php -d error_reporting=0 -r "imagefill($i=imagecreatetruecolor(99,99),0,0,2**24-1);foreach([I,' ',V,o,t,e,d]as$k=>$e)imagestring($i,2,$k*9,0,$e,!$k|$k&1?0xFF0000:255);imagepng($i);" > output.png
```
Output:
[![enter image description here](https://i.stack.imgur.com/3VOlE.png)](https://i.stack.imgur.com/3VOlE.png)
[Answer]
# Xamarin.Forms C#, ~~317~~ 313 bytes
```
using Xamarin.Forms;public class A:Application{public A(){var s=new StackLayout{BackgroundColor=Color.White,Orientation=(StackOrientation)1,VerticalOptions=LayoutOptions.End};foreach(var c in"I Voted")s.Children.Add(new Label{Text=c+"",TextColor=c%2<1?Color.Blue:Color.Red});MainPage=new ContentPage{Content=s};}}
```
[![](https://na.cx/i/9TFm9r.jpg)](https://na.cx/i/9TFm9r.jpg)
`VerticalOptions=LayoutOptions.End` is needed for iOS, otherwise the text will be overlayed by status bar. No problem on Android so can save 34 bytes including comma.
*Edit: 2016-11-14: -4 bytes*
Ungolfed
```
using Xamarin.Forms;
public class A : Application
{
    public A()
    {
        // Make a horizontal StackLayout for labels
        var s = new StackLayout
        {
            BackgroundColor = Color.White,
            Orientation = (StackOrientation)1,   // StackOrientation.Horizontal
            VerticalOptions = LayoutOptions.End
        };
        foreach(var c in "I Voted")
            // Make a new label for each letter, then add to StackLayout
            s.Children.Add(new Label
                {
                    // Cast char to string
                    Text = c + "",
                    // Happens that 'I', 'o', and 'e' are all odd in ASCII, and 'V', 't', and 'd' are all even :)
                    TextColor = c%2<1 ? Color.Blue : Color.Red   
                }
            );
        // Set app MainPage to be a new ContentPage, where the content is the StackLayout above
        MainPage = new ContentPage { Content = s };
    }
}
```
[Answer]
# x86 machine code + DOS + BIOS, 25 bytes
Hexdump:
```
b8 02 13 b1 07 bd 0b 01 cd 10 c3 49 74 20 74 56
71 6f 74 74 71 65 74 64 71
```
Assembly code (suitable as input to `debug.com`, so all numbers are hexadecimal):
```
mov ax, 1302
mov cl, 7
mov bp, 10b
int 10
ret
db 'It tVqottqetdq'
```
It uses a [BIOS routine](http://vitaly_filatov.tripod.com/ng/asm/asm_023.20.html) to output the string to the display memory. The string will appear at a "random" position on screen (see below), like this:
[![screenshot](https://i.stack.imgur.com/DVUI8.png)](https://i.stack.imgur.com/DVUI8.png)
The string contains the letters `I V o t e d`, interleaved with "attributes"
```
74 74 71 74 71 74 71
```
that specify the colour of the letters. Here 7 as the most significant digit means "white background", and the least significant digit specifies the foreground (1=blue; 4=red).
The display position of the string is specified by the `dx` register. As mentioned [here](http://pferrie.host22.com/misc/lowlevel12.htm), the initial value of this register is equal to the value of the `cs` register. And the value of that one is the first available address in memory, after DOS is loaded.
The size of DOS is typically less than 64K, that is, the segment address of the loaded user's program is less than hexadecimal `1000`. So the output will appear somewhere around the first 16 lines of text on the display. In my example, it appeared at line 8 (the upper half of `dx`, called `dh`, is equal to 8).
The low half of `dx`, called `dl`, contains the column at which the text is output. Experiments show that BIOS doesn't check overflow, so it doesn't matter 
if `dx` asks for output at e.g. column 100.
]