What are the names of numbers in the binary system? The names we use are very much related to the radix we use
$0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9$
zero - one - two - three - four - five - six - seven - eight -nine
We repeat the names
$21$ twenty one, $22$ twenty two .. and so on.
This is not suitable for binary system
If we used the same nomenclature
$1 - \text{one}$
$10 - \text{two}?$
$11 - \text{three}?!$
This is very hard to read and write
Maybe if we used something else it would be very convenient something like:

$1 - \text{John}$
$10 - \text{Watson}$
$11 - \text{Watson John}$
$100 - \text{Kevin}$
$101 - \text{Kevin John}$
$110 - \text{Kevin Watson}$
$111 - \text{Kevin Watson John}$

and so on ..
Is there any official nomenclature? or should I make it up myself?
 A: 
The names we use are very much related to the radix we use

Etymologically, perhaps, though with some exceptions and inconsistencies as noted already.
The more important point, however, is that the names are used to denote the numbers themselves, not some particular representation of them.
Take for example "two plus three equals five". That's a statement about numbers, which holds true regardless of their representation. All of $2_{10}+3_{10}=5_{10}$ in decimal, or $10_2+11_2=101_2$ in binary or $II + III = V$ in roman numerals represent the same statement "two plus three equals five", and there is no need for different words to describe it depending on the representation.
A: Well the way I read it
1 - one
10 - one zero
11 - one one 
etc.
Although this might get inconvenient for large number of bits.
A: If you want to talk about the numbers then $21_{10}$ is called twenty-one as $10101_{2}$ or $210_3$, etc. You may use pair if you want: $10_2$ could be named one-pair or pair as $10_3$ is one-triplet or triplet.
If you want to spell the writings then $21$  is two-one and $10101$ is one-zero-one-zero-one.
Words have no meaning per se, you should give context to be clear. So $10101$ is just a sequence of digits (letters), but if you say it is the 10-base writing of a number you can name it ten-thousand-one-hundred-and-one, or twenty-one if base 2 is the context, etc.
A: You can pronounce 11001 in binary (so 25 in decimal) as "eleven thousand and one in binary".
Let me be clear: I represent a minority view, and am aware of this.

In his answer, dxiv says that "the names of numbers are used to denote the numbers themselves [(quantity they represent)], not some particular representation of them" (italic is my addition). That is an opinion one can have. For me, "the names of numbers are used to denote a particular representation of quantity, not the quantity that they represent. That is also an opinion.
In a comment, Octopus said that it is "incredibly misleading" to read binary 11 as "eleven". Octopus probably says this because he is of the opinion that "eleven" is used for 1+1+1+1+1+1+1+1+1+1+1, while binary 11 stands for 1+1+1. But it is only misleading because we should mention the base system in both cases: I read "binary 11" as "binary eleven", just as I read "11" as "eleven". 
I would say that it is misleading to say that "eleven" always stands for 1+1+1+1+1+1+1+1+1+1+1. If we write numbers in digits, we should be clear about which base is used. I believe that we should also do this when we "say" numbers.
So for me, "1000" is always read as "thousand". In base 2, base 4, base 10, base 64, whatever. The quantity that "thousand" represents, depends on the base, just as the quantity that "1000" represents. I don't see anything misleading about that.
Talking about the binary 1011, I would be confused if somebody reads this as "eleven". If we have established that we are working in a binary system, it is confusing to use the decimal system without warning. It is perfectly acceptable, and not ambiguous, to call this "decimal eleven" or "eleven in decimal". Or "binary one thousand and eleven". Or, because we have already established that we are talking binary, "one thousand and eleven". 
What happens in practice: binary numbers get too large easily, so we spell the digits: "one oh one one".

Edited to add: I find it difficult to express why I would read "101" as "hundred and one" regardless of the base, because it is so obvious and natural to me.
I distinguish three different concepts related to a number:


*

*A. The quantity ($1+1+1$)

*B. The written notation ("3")

*C. How to say a number ("three")


Compare it to the three concepts related to a word (example: cat):


*

*A. The underlying concept (the animal that says "meow")

*B. The written notation ("cat")

*C. How to say this (/'kæt/)


If we go to a different base, for me it is like going to a different language. If I switch from English to German, the written notation changes (to "Katze"). If I read this word out loud, I don't say /'kæt/, but I (try to) say it the way that Germans do.
For me, reading $101_2$ as "five" is just as silly as reading "Katze" as /'kæt/. If you do that, you are mixing up languages in a (for me) very confusing way. 
A: The straightforward answer to your question is that it is conventional to use either the base $10$ name of the number, such as "twenty one", or to list the binary sequence of ones and zeroes from the left, i.e. "one, zero, one, zero, one".
Either one is entirely satisfactory.
A: OK so I guess I'm the only one who would call those numbers "one", "ten", "eleven", "one hundred", "one hundred and one", etc, reasoning that the words we use to describe the number reflect the number's representation in the base we're using and not the number's actual magnitude? (to be fair it makes the very term "base 10" nonsensical/tautologous but that's true in writing as well, as evidenced by the fact that I wrote "base 10" when I meant "base ten" and didn't notice until I'd almost finished the paragraph because they're both the same thing, and both equally fall on the ambiguity between "the representation of the first number in any given base that needs two digits to represent" and "the number of fingers most humans have". Which itself is an unavoidable consequence of the fact our human languages were built to treat numbers and their representation in whatever base the language uses as interchangeable).
A: Perhaps it would be easiest with sounds. Since computers do this by on/off, perhaps just clapping and snapping for 1 and 0 respectively. Alternatively, if you can sing, just pick two notes and alternate. This would be easier to tell and probably easier to remember if it's musically or rhythmically interpreted.
A: To expand on the comment by Robert Israel, I think the question rests on a basic misunderstanding, namely that numerals in a number system need names to refer to them. Numbers are abstract mathematical quantities, and numerical representations and number names are just ways to refer to numbers. Many different ways exist to refer to the same number, but none of these refers to another way to refer to the number, but just to the number itself. There is as integer that can be referred to by any of $87$, "eighty seven", LXXXVII, $1010111_2$, "four score and seven", and many other ways. However the name "eighty seven" does not refer to any of the other representations, nor does any other name.
A: While English mostly uses base-ten layout in naming numbers, that's not entirely true. We have number names which are completely divorced from base ten ("dozen", "score", "gross"). In our "standard" numbers, we have things like "eleven" and "twelve". If we were strictly base-ten in naming numbers, these should be "tenty-one" and "tenty-two". Why do we have special names for quantities in the tens place and not the hundreds? Why is it "three hundred eight", but "thirty eight" instead of "three tens and eight"? Why do we have special names for 102 and 103 ("hundred" and "thousand") but not 104? - We only pick it up again at 106. Why do we have a base-three scheme in the powers? 
But I'm more thinking of some other languages, which can deviate from base-ten numbering. (Video about "odd" numering schemes in other languages) For example, in French 87 is quatre-vingt-sept (four twenties and seven) ... but when writing it in numerical digits, they still write it as "87" -- no one in France uses base-twenty numerical system. When they write "47", they mean the same as English-speakers do. In Danish it gets stranger, as 58 is otteoghalvtreds which is a contracted version of "eight and one-half-subtracted-from-three (2½) times twenty". Again, no one in Denmark would be writing something like "2½8" when they mean fifty-eight; they write "58".
The upshot is that while the names of the numbers are influenced by our base-ten numerical system, they're not entirely determined by it. The name of our numbers are the name of our numbers. It's not changed by how we write them. So, yes, 112 is "three" and if you tell your robot to pick up 11002 eggs, it's picking up "twelve" of them. It might be a little confusing to translate from "twelve" to 11002, but not any more so than for a Danish person to remember that 58 is really "eight and one-half-substracted-from-three times twenty".
Making up a new system is right out. The point of language is communication, and if you make up your own scheme, it greatly inhibits communication with other people, who in general will not know the scheme, or are using a different one.
A: If you give names to each place, you're going to need a lot of names.  Binary numbers grow in length faster than any other integral base (besides unary which doesn't entirely count).  While we could invent a system, it would be more trouble than it's worth.  Usually, binary numbers are just read as digits - 110 is "one one zero" - or converted to decimal - 110 is "six."
However, in cases where the binary number is very long, both these techniques are inefficient.  In the specific context of computer science and software engineering (the fields that most commonly need to do this), we typically switch to a more convenient base.  This is less difficult than it sounds, because power-of-two bases have a nice property: every digit in base $2^n$ maps directly to $n$ digits in base 2.  For example, take $1011011010_2$; after padding it with leading zeros, we get:
$$
0010_2 = 2_{16} \\
1101_2 = \mathrm{D}_{16} \\
1010_2 = \mathrm{A}_{16} \\
{0010\;1101\;1010}_2 = \mathrm{2DA}_{16}
$$
As you can see, the hexadecimal representation is much shorter, and far less cumbersome to read and write even without hex place names.  At the same time, it preserves the structure and grouping of the bits, so that we can reason about the binary form while looking at the hex form.
Hexadecimal is an especially popular representation for several reasons:


*

*It's small enough that one could reasonably memorize the conversion between binary and hex.

*Even without outright memorization, converting a four-bit value can be done by hand with little difficulty.

*Four bits is a simple fraction of eight bits, which is a common unit in real hardware.


*

*If you want to preserve this property, the only other options are base 4 and base 256.  Base 4 is only slightly more efficient than binary, and base 256 is difficult to notate.


*It is compact enough to save a significant amount of space.


You will occasionally see octal (base 8) used in places where bits need to be put into groups of three for some reason.  The commonest instance of this is Unix permission bits, which make more sense as four groups of three than as three groups of four.
If base 16 is not compact enough, we can go all the way to Base64, which grabs six bits at a time.  As the name suggests, this comes with a standardized notation, which can be slightly idiosyncratic.  For example, it distinguishes between $\mathrm{a}_{64}$ and $\mathrm{A}_{64}$.  A bit more controversially, it makes use of three non-alphanumeric symbols in order to complete the base, most commonly $+$, $/$, and $=$.  Obviously, you would not want to put this into an equation or other mathematical expression of any kind.  The only real advantage of this system is that it is highly compact, yet fits comfortably into ASCII without requiring any special characters that might be mishandled by poorly-implemented software.
A: Let me take 11111 in base two as an example. I'll use "base two" and "binary" interchangibly.
If you want to be understood, you are best off pronouncing it "thirty-one in binary", or, more accurately, "the binary representation of thirty-one". However, it is not always immediately obvious what the corresponding base 10 number is to a binary representation.
You can just pronounce it like you would pronounce it as a base 10 number: eleven thousand one hundred and eleven. This is bound to cause confusion though.
A reasonable option is to just read the numbers one by one: "one one one one one" or maybe "binary one one one one one". The disadvantage is that numbers will be long this way.
Another option is to convert to hexadecimal (base 16) notation and pronounce it "hex one ef". This is perhaps the best option. The conversion is straightforward and by using the prefix it is obvious that you are referring to a number in hexadecimal notation. This is well-known format for low-level computer programmers.
A: Not an answer, too long for a comment.
This turns out to be an interesting question when teaching kids about arithmetic and writing numbers with a base other than $10$. It's important not to read $101_2$ or $101_{12}$ as "one hundred one". Reusing the old name is more than merely confusing, it blunts the important distinction between a number and a name of a number.
You need a name for each digit - it's customary to use the single decimal digits as long as the base is less than or equal to ten. But you do need  new names for the next columns, as the question suggests.
You might enjoy this discussion of a session with some fourth graders:
http://www.cs.umb.edu/~eb/segm.pdf
A: A Number is a value, and any "name" assigned to the value remains the same regardless of it's notation (hexadecimal, binary, decimal).
A Numeral is a representative symbol used in the writing of a number in a particular radix or base. There are common ones (binary 0,1) and there are less common representations (binary off, on). Roman Numerals would probably be the best known of the less common representations.
Common written forms for groups of numerals may need to be notated with the radix or number system that is in play if there is a chance of confusion; CC could be interpreted (in decimal values) as 4, 144, 200 depending upon the system in place (respectively base64, hexadecimal, Roman Numerals).
Names are really just standards that mankind has adopted and forgotten as time has gone on. Some are a very common and precise (twenty two) and others are less common or imprecise (score, eon).
So in reference to your original question

Is there any official nomenclature? or should I make it up myself?

It's all up to you. You could use common names, less common names, or make up your own naming convention. That is what science fiction and fantasy writers have  been doing. 

Update

Had to do some actually programming work since I attempted to post this about 8 hours before it actually got submitted (ugh), but I did have some work that involved reading streams.
Anyways, The text value twenty-one is normally written as decimal 21. In binary the this would be 10101, which would normally be written in its n^2 form of 00010101. This representation still reflects the (standard decimal) value 21 and should be referred to as such unless you are utilizing an alternative naming system. The actual 0s and 1s that are in it should be pronounced as such; 10101 in this context is actually a bitstream (or bit sequence).
Hexadecimal is a little different, especially in some usages such as RGB colors, #FF0000 would normally be read as a bytestream of F-F-0-0-0-0, or could be (255, 0,0), or could just simply be "Red".
Of course, it all comes down to preferences as to what your naming system is going to be. Just make sure everyone knows the realm you are dealing with.
A: I'm surprised that this discussion is happening on a mathematics list. I'd have expected it under English Language or Computer science or even  Electrical Engineering.
From the maths point of view, "thirteen" is a name for a number. That number is independent of how it is named: it's a deep philosophical question whether it might even exist independently of the universe within which it is named. Anyway, one might also refer to it as the sixth prime number, or "13", or "0xd", or "binary 1011". 
It's not particularly common in mathematics for the pattern of the digits in any particular number base to be of any interest. One is dealing with deeper properties of the numbers (for example the infinite set of prime numbers, the finite set of prime factors of a particular number). One often starts by giving unknown numbers  or sets of numbers a name, and then derives properties thereof. (I can't remember anything about "mice", except that somebody once published a paper in which he stated "let us refer to such numbers as 'nice', which was misprinted as 'mice', and the name stuck).  
Computer Science / Engineering note. The interface between a computer and electronics which it is controlling is called a register. When one writes 0x54 to a register, it is often useful to expand that in binary: 01011000, and it is then possible to relate to the hardware manual for the meanings of those eight bits as signal wires connected to the register which have just been set to their low (usually logic 0) or high (usually logic 1) voltage. Other registers work the other way: one reads them to collect the logic levels off a set of wires. It doesn't make any sense to refer to this "number" in decimal because it is not fundamentally a number. (It doesn't enumerate anything, it is just an ordered sequence of states). Indeed, an engineer familiar with the hardware might read it directly as "Left indicator, Right indicator, Brake lights", think "that's strange" and then work out that it probably means the hazard indicator switch is on while the vehicle is being moved. In a program it would be better to write (say) K_LEFTI | K_RIGHTI | K_BRAKEL rather than 0x54, to make the code self-documenting.
A: In addition to Narek's answer…

Is there any official nomenclature?

No.

or should I make it up myself?

Not if you want to be understood by other people!
A: The number name stays the same in any base. This becomes more obvious when we look at some of the numbers you skipped over in the question.
Eleven, Twelve, Thirteen, Fourteen, ...
Now those numbers were named long before humans were thinking too deeply what base numbering system to use - but those are the names we have (at least in english) and they don't get renamed to onety-one, onety-two, onety-three, onety-four just because we using base 10.
A: Base 10 based names can be used to name a binary number, but they are awkward and don't align well.  I mean, I go and add a single 1 to the binary number, and the entire name changes?  Ridiculous.
Naming each digit separately will run into problems.  We don't do this in base 10; instead, we name groups.  We don't have a name for 100,000, instead we say "one hundred thousand".  A similar pattern for binary makes sense.
Your names -- John Watson and Kevin -- are one approach.  But an efficient way that is in wide use is to use hexidecimal names.
Here, we clump the binary digits into groups of 4.  We then name that group of 4 with one word, sort of like thirteen.
0000 zero
0001 one
0010 two
0011 three

0100 four
0101 five
0110 six
0111 seven

1000 eight
1001 nine
1010 A
1011 B

1100 C
1101 D
1110 E
1111 F

We can now name a long binary number:
100010101010101010010101011000011
by grouping by 4s:
1 0001 0101 0101 0101 0010 1010 1100 0011

then translating:
1 1 5 5 5 2 5 C 3

we then compress, and prepend with 0x to indicate we are describing it in hexidecimal:
0x1155525C3

and done.  If we tweak single bits, or prepend a bit, the name stays mostly stable.  If you insert a digit, everyting "higher" gets renamed, but the same is true of decimal names.
Hex was basically designed to be a more friendly way to communicate binary numbers.
A: From the DozensOnline Forum:, this is my standard

We need a name for each bit, at-least up-to 8 bits. The easy part is that we don't have-to deal with annoying multiples.
2^0 - un
2^1 - du
2^2 - tet
2^3 - oct
2^4 - hex
2^5 - trec
2^6 - sexet
2^7 - went
2^8 - viva
I very quickly ran out of monosyllabic names, and had to improvise, not to mention ;1,000,000 (64) isn't even monosyllabic!
However, using this convention, ;1010 (10) would be oct-du


EDIT
A more Englishy approach is:

*

*0 - zero

*1 - one

*10 - two

*100 - three

*1000 - four

*1,0000 - five

*10,0000 - six

*100,0000 - seven

*1000,0000 - eight

*1,0000,0000 - nine

*10,0000,0000 - ten

*100,0000,0000 - eleven

*1000,0000,0000 - twelve

A: Here's a compromise that will never catch one.
1: one
10: two
11: twoty-one
100: four
101: forty-one
110: forty-two
111: forty-twoty-one
1000: eight
....
1111: eighty-forty-twoty-one
eventually we'll have to stop calling $10^k$ but then base ten equivalence.  "sixteen" which means "ten and six" is no longer a single unitary word so that's a good place to stop
1,0000: ant (huh?  be patient it will become clear)
1,0000: instead of giving this name it is two-ant.(because it is ... two ant.  This  is equivalent to base tens word for $10,000$ as "ten thousand".  Just as at this stage only have new names for $10^{3k}$ in base ten: thousand, million, billion, trillion.... Here we will only have names for $10^{4k}$.  And for convenience we well use commas for blocks of $4$, not $3$.)
1111,1111: eighty-forty-twoty-one ant eighty-forty-twoty-one.
1,0000,0000: bear
1,0000,0000,0000: cat
.....
$1,0000^{26}$: zebra.
So we run out of names when we don't have a name for $1,0000^{2\times 26} = 2^{208}\approx 4.114\times 10^{62}$.  But if that becomes an an issue it can be "zebra-zebra" and we can hope will expressing the names of binary numbers with over 208 digits that our lack of pause at the first name of a number will indicate we actually mean a magintude of zebra times that number. (Equivalent to "seven million 5 thousand million and twenty seven"$=7,005,000,000,027$ and the first "million" is a "million million"; not a single million).  Hopefully it will become easy with practice.
Not bad, eh?
I'll just sit here waiting for it to catch on.
