[Question]
  [
**Input:** Two integers. Preferably decimal integers, but other forms of numbers can be used. These can be given to the code in standard input, as arguments to the program or function, or as a list.
**Output:** Their sum. Use the same format for output integers as input integers. For example, the input `5 16` would lead to the output `21`.
**Restrictions:** No standard loopholes please. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), answer in lowest amount of bytes wins.
**Notes:** This should be fairly trivial, however I'm interested to see how it can be implemented. The answer can be a complete program or a function, but please identify which one it is.
**Test cases:** 
```
1 2 -> 3
14 15 -> 29
7 9 -> 16
-1 8 -> 7
8 -9 -> -1
-8 -9 -> -17
```
Or as CSV:
```
a,b,c
1,2,3
14,15,29
7,9,16
-1,8,7
8,-9,-1
-8,-9,-17
```
# Leaderboard
```
var QUESTION_ID=84260,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# Minecraft 1.10, 221 characters (non-competing)
See, this is what we have to deal with when we make Minecraft maps.
Aside: There's no way to take a string input in Minecraft, so I'm cheating a bit by making you input the numbers into the program itself. (It's somewhat justifiable because quite a few maps, like Lorgon111's Minecraft Bingo, require you to copy and paste commands into chat in order to input a number.)
Thank you abrightmoore for the [Block Labels](http://www.brightmoore.net/mcedit-filters-1/blocklabels) MCEdit filter.
[![a](https://i.stack.imgur.com/ucoxq.png)](https://i.stack.imgur.com/ucoxq.png)
```
scoreboard objectives add a dummy
scoreboard players set m a 6
scoreboard players set n a 8
scoreboard players operation r a += m a
scoreboard players operation r a += n a
tellraw @a {"score":{"name":"r","objective":"a"}}
```
Non-competing due to difficulties in input, and I have no idea how to count bytes in this thing (the blytes system is flawed for command blocks).
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 1 byte
```
+
```
[Try it online!](http://jelly.tryitonline.net/#code=Kw&input=&args=NQ+MTY)
Also works in 05AB1E, Actually, APL, BQN, Brachylog, Braingolf, Chocolate, ,,, (Commata), dc, Deorst, Factor, Fig\*\*, Forth, Halfwit\*, HBL\*, Implicit, J, Julia, K, kdb+, Keg, Ly, MathGolf, MATL, Pyke, Q, Racket, Scheme, Swift, Thunno\*\*, Thunno 2, and Vyxal.
\* Language uses a half-byte code page, and therefore `+` counts as 0.5 bytes.
\*\* In Fig and Thunno, this is \$\log\_{256}(96)\approx\$ 0.823 bytes.
[Answer]
# [Binary lambda calculus](https://en.wikipedia.org/wiki/Binary_lambda_calculus), 4.125 bytes
Input and output as [Church numerals](https://en.wikipedia.org/wiki/Church_encoding).
```
00000000 01011111 01100101 11101101 0
```
In [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus), it is λ*m*. λ*n*. λ*f*. λ*x*. *m* *f* (*n* *f* *x*).
[De Bruijn index](https://en.wikipedia.org/wiki/De_Bruijn_index): λ λ λ λ 4 2 (3 2 1)
---
[Lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus) is a concise way of describing a mapping (function).
For example, this task can be written as λ*x*. λ*y*. *x* + *y*
The thing to note is, that this is not a lambda (function) which takes two arguments. This is actually a nested lambda. However, it behaves like a lambda which takes two arguments, so it can be informally described as such. Every lambda formally only takes one argument.
For example, if we apply this lambda to 3 and 4:
> 
> (λ*x*. λ*y*. *x* + *y*) 3 4 ≡ (λ*y*. 3 + *y*) 4 ≡ 3 + 4 = 7
> 
> 
> 
So, the first lambda actually returns another lambda.
---
[Church numerals](https://en.wikipedia.org/wiki/Church_encoding) is a way of doing away with the extra signs, leaving with only lambda symbols and variables.
Each number in the Church system is actually a lambda that specifies how many times the function is applied to an item.
Let the function be *f* and the item be *x*.
So, the number 1 would correspond to λ*f*. λ*x*. *f* *x*, which means apply *f* to *x* exactly once.
The number 3, for example, would be λ*f*. λ*x*. *f* (*f* (*f* *x*)), which means apply *f* to *x* exactly three times.
---
Therefore, to add two [Church numerals](https://en.wikipedia.org/wiki/Church_encoding) (say, *m* and *n*) together, it is the same as applying *f* to *x*, *m* + *n* times.
We can observe that this is the same as first applying *f* to *x*, *n* times, and then applying *f* to the resulting item *m* times.
For example, *2* would mean `f(f(x))` and *3* would mean `f(f(f(x)))`, so *2* + *3* would be `f(f(f(f(f(x)))))`.
To apply *f* to *x*, *n* times, we have *n* *f* *x*.
You can view *m* and *n* as functions taking two arguments, informally.
Then, we apply *f* again to this resulting item, *m* times: *m* *f* (*n* *f* *x*).
Then, we add back the boilerplate to obtain λ*m*. λ*n*. λ*f*. λ*x*. *m* *f* (*n* *f* *x*).
---
Now, we have to convert it to [De Bruijn index](https://en.wikipedia.org/wiki/De_Bruijn_index).
Firstly, we count the "relative distance" between each variable to the lambda declaration. For example, the *m* would have a distance of 4, because it is declared 4 lambdas "ago". Similarly, the *n* would have a distance of 3, the *f* would have a distance of 2, and the *x* would have a distance of 1.
So, we write it as this intermediate form: λ*m*. λ*n*. λ*f*. λ*x*. 4 2 (3 2 1)
Then, we remove the variable declarations, leaving us with: λ λ λ λ 4 2 (3 2 1)
---
Now, we convert it to [binary lambda calculus](https://en.wikipedia.org/wiki/Binary_lambda_calculus).
The rules are:
* λ becomes `00`.
* *m* *n* (grouping) becomes `01 m n`.
* numbers *i* becomes `1` *i* times + `0`, for example 4 becomes `11110`.
λ λ λ λ 4 2 (3 2 1)
≡ λ λ λ λ `11110` `110` (`1110` `110` `10`)
≡ λ λ λ λ `11110` `110` `0101 111011010`
≡ λ λ λ λ `0101` `111101100101111011010`
≡ `00` `00` `00` `00` `0101` `111101100101 111011010`
≡ `000000000101111101100101111011010`
[Answer]
## [Stack Cats](https://github.com/m-ender/stackcats), 8 + 4 = 12 bytes
```
]_:]_!<X
```
Run with the `-mn` flags. [Try it online!](http://stackcats.tryitonline.net/#code=XV86XV8hPFg&input=NTcgLTE4OA&args=LW1u)
Golfing in Stack Cats is *highly* counterintuitive, so this program above was found with a few days of brute forcing. For comparison, a more intuitive, human-written solution using the `*(...)>` template is two bytes longer
```
*(>-_:[:)>
```
with the `-ln` flags instead (see the bottom of this post for an explanation).
### Explanation
Here's a primer on Stack Cats:
* Stack Cats is a reversible esoteric language where the mirror of a snippet undoes the effect of the original snippet. Programs must also be mirror images of itself — necessarily, this means that even-length programs are either no-ops or infinite loops, and all non-trivial terminating programs are of odd length (and are essentially a conjugation of the central operator).
* Since half the program is always implied, one half can be left out with the `-m` or `-l` flag. Here the `-m` flag is used, so the half program above actually expands to `]_:]_!<X>!_[:_[`.
* As its name suggests, Stack Cats is stack-based, with the stacks being bottomless with zeroes (i.e. operations on an otherwise empty stack return 0). Stack Cats actually uses a tape of stacks, e.g. `<` and `>` move one stack left and one stack right respectively.
* Zeroes at the bottom of the stack are swallowed/removed.
* All input is pushed to an initial input stack, with the first input at the top and an extra -1 below the last input. Output is done at the end, using the contents of the current stack (with an optional -1 at the bottom being ignored). `-n` denotes numeric I/O.
And here's a trace of the expanded full program, `]_:]_!<X>!_[:_[`:
```
    Initial state (* denotes current stack):
      ... [] [-1 b a]* [] [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [a]* [] ...
_   Reversible subtraction, performing [x y] -> [x x-y] (uses an implicit zero here)
      ... [] [-1 b] [-a]* [] ...
:   Swap top two
      ... [] [-1 b] [-a 0]* [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [-a] []* ...
_   Reversible subtraction (0-0, so no-op here)
!   Bit flip top element, x -> -x-1
      ... [] [-1 b] [-a] [-1]* ...
<   Move one stack left
      ... [] [-1 b] [-a]* [-1] ...
X   Swap the stack to the left and right
      ... [] [-1] [-a]* [-1 b] ...
>   Move one stack right
      ... [] [-1] [-a] [-1 b]* ...
!   Bit flip
      ... [] [-1] [-a] [-1 -b-1]* ...
_   Reversible subtraction
      ... [] [-1] [-a] [-1 b]* ...
[   Move one stack left, taking the top element with you
      ... [] [-1] [-a b]* [-1] ...
:   Swap top two
      ... [] [-1] [b -a]* [-1] ...
_   Reversible subtraction
      ... [] [-1] [b a+b]* [-1] ...
[   Move one stack left, taking the top element with you
      ... [] [-1 a+b]* [b] [-1] ...
```
`a+b` is then outputted, with the base -1 ignored. Note that the trickiest part about this solution is that the output stack must have a `-1` at the bottom, otherwise an output stack of just `[-1]` would ignore the base -1, and an output stack of `[0]` would cause the base zero to be swallowed (but an output stack of `[2]`, for example, would output `2` just fine).
---
Just for fun, here's the full list of related solutions of the same length found (list might not be complete):
```
]_:]^!<X
]_:]_!<X
]_:]!^<X
]_:!]^<X
[_:[^!>X
[_:[_!>X
[_:[!^>X
[_:![^>X
```
The `*(>-_:[:)>` solution is longer, but is more intuitive to write since it uses the `*(...)>` template. This template expands to `<(...)*(...)>` when used with the `-l` flag, which means:
```
<       Move one stack left
(...)   Loop - enter if the top is positive and exit when the top is next positive again
        Since the stack to the left is initially empty, this is a no-op (top is 0)
*       XOR with 1 - top of stack is now 1
(...)   Another loop, this time actually run
>       Move one stack right
```
As such, the `*(...)>` template means that the first loop is skipped but the second is executed. This allows more straightforward programming to take place, since we don't need to worry about the effects of the loop in the other half of the program.
In this case, the inside of the loop is:
```
>       Move one stack right, to the input stack
-       Negate top, [-1 b a] -> [-1 b -a]
_       Reversible subtraction, [-1 b -a] -> [-1 b a+b]
:       Swap top two, [-1 b a+b] -> [-1 a+b b]
[       Move one stack left, taking top of stack with you (removing the top b)
:       Swap top two, putting the 1 on this stack on top again
```
The final `>` in the template then moves us back to the input stack, where `a+b` is outputted.
[Answer]
## Common Lisp, 15 bytes
```
(+(read)(read))
```
[Answer]
# [Dominoes](http://store.steampowered.com/app/286160/), 38,000 bytes or 37 tiles
This is created in [*Tabletop Simulator*](http://store.steampowered.com/app/286160/). Here is a [video](https://www.youtube.com/watch?v=LYCAiD80oZU&feature=youtu.be) and here is the [file](http://steamcommunity.com/sharedfiles/filedetails/?id=883290024). It is a standard half-adder, composed of an `and` gate for the `2^1` place value and an `xor` gate for the `2^0` place value.
[![enter image description here](https://i.stack.imgur.com/TUQerm.jpg)](https://www.youtube.com/watch?v=LYCAiD80oZU&feature=youtu.be)
## Details
* **I/O**
	+ **Start** - This is included for clarity (not counted towards total) and is what 'calls' or 'executes' the function. Should be 'pressed' after input is given **[Yellow]**.
	+ **Input A** - This is included for clarity (not counted towards total) and is 'pressed' to indicated a `1` and unpressed for `0` **[Green]**.
	+ **Input B** - This is included for clarity (not counted towards total) and is 'pressed' to indicated a `1` and unpressed for `0` **[Blue]**.
	+ **Output** - This is counted towards total. These dominoes declare the sum. The left is `2^1` and the right is `2^0` **[Black]**.
* **Pressing**
	+ To give input or start the chain, spawn the metal marble
	+ Set the lift strength to `100%`
	+ Lift the marble above the desired domino
	+ Drop the marble
[Answer]
# [Brain-flak](http://github.com/DJMcMayhem/Brain-Flak), 6 bytes
```
({}{})
```
[Try it online!](http://brain-flak.tryitonline.net/#code=KHt9e30p&input=MyA1)
Brain-flak is a really interesting language with two major restrictions on it.
1. The only valid characters are brackets, i.e. any of these characters:
```
 (){}[]<>
```
2. Every single set of brackets must be entirely matched, otherwise the program is invalid.
A set of brackets with nothing between them is called a "nilad". A nilad creates a certain numerical value, and all of these nilads next to each other are added up. A set of brackets with something between them is called a "monad". A monad is a function that takes an numerical argument. So the brackets inside a monad are evaluated, and that is the argument to the monad. Here is a more concrete example.
The `()` *nilad* equals 1. So the following brain-flak code:
```
()()()
```
Is evaluated to 3. The `()` *monad* pushes the value inside of it on the global stack. So the following
```
(()()())
```
pushes a 3. The `{}` nilad pops the value on top of the stack. Since consecutive nilads are always added, a string of `{}` sums all of the top elements on the stack. So my code is essentially:
```
push(pop() + pop())
```
[Answer]
# Minecraft 1.10.x, ~~924~~ 512 bytes
Thanks to @[quat](https://codegolf.stackexchange.com/users/34793/quat) for reducing the blytecount by 48 points and the bytecount by 412.
Alright, so, I took some of the ideas from [this answer](https://codegolf.stackexchange.com/a/84342/44713) and made a version of my own, except that this one is capable of accepting non-negative input. A version may be found [here](https://www.dropbox.com/s/6v20ca187bjdpw5/Input%20Ready.nbt?dl=1) in structure block format.
[![group](https://i.stack.imgur.com/tUA1C.png)](https://i.stack.imgur.com/tUA1C.png)
(new version looks kinda boring tbh)
Similar commands as the other answer:
```
scoreboard objectives add a dummy
execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1
execute @e[type=Cow] ~ ~ ~ scoreboard players add n a 1
scoreboard players operation n a += m a
tellraw @a {"score":{"name":"n","objective":"a"}}
```
To input numbers, spawn in a number of cows and pigs. Cows will represent value "n" and pigs will represent value "m". The command block system will progressively kill the cows and pigs and assign values as necessary.
This answer assumes that you are in a world with no naturally occurring cows or pigs and that the values stored in "n" and "m" are cleared on each run.
[Answer]
## [Retina](https://github.com/m-ender/retina), 42 bytes
```
\d+
$*
T`1p`-_` |-1+
+`.\b.
^(-)?.*
$1$.&
```
[Try it online!](http://retina.tryitonline.net/#code=XGQrCiQqClRgMXBgLV9gIHwtMSsKK2AuXGIuCgpeKC0pPy4qCiQxJC4m&input=LTUgMTY)
### Explanation
Adding numbers in unary is the easiest thing in the world, but once you introduce negative numbers, things get fiddly...
```
\d+
$*
```
We start by converting the numbers to unary. This is done by matching each number with `\d+` and replacing it with `$*`. This is a Retina-specific substitution feature. The full syntax is `count$*character` and inserts `count` copies of `character`. Both of those can be omitted where `count` defaults to `$&` (i.e. the match itself) and `character` defaults to `1`. So for each input `n` we get `n` ones, and we still have potential minus signs in there, as well as the space separator. E.g. input `8 -5` gives:
```
11111111 -11111
```
Now in order to deal with negative numbers it's easiest to use a separate `-1` digit. We'll use `-` for that purpose.
```
T`1p`-_` |-1+
```
This stage does two things. It gets rid of the space, the leading minus signs, and turns the `1`s after a minus sign into `-` themselves. This is done by matching  `|-1+` (i.e. either a space or a negative number) and performing a transliteration on it. The transliteration goes from `1p` to `-_`, but here, `p` expands to all printable ASCII characters and `_` means delete. So `1`s in those matches get turned into `-`s and minuses and spaces get removed. Our example now looks like this:
```
11111111-----
```
```
+`.\b.
```
This stage handles the case where there's one positive and one negative number in the input. If so, there will be `1`s and `-`s in the string and we want them to cancel. This is done by matching two characters with a word-boundary between them (since `1`s is considered a word character and `-` isn't), and replacing the match with nothing. The `+` instructs Retina to do this repeatedly until the string stops changing.
Now we're left with *only* `1`s or *only* `-`s.
```
^(-)?.*
$1$.&
```
To convert this back to decimal, we match the entire input, but if possible we capture a `-` into group `1`. We write back group `1` (to prepend a `-` to negative numbers) and then we write back the length of the match with `$.&` (also a Retina-specific substitution feature).
[Answer]
# Geometry Dash - 15 objects
Finally done.  
15 objects aren't much, but it was still a nightmare to do this (especially because of the negative numbers).
[![enter image description here](https://i.stack.imgur.com/ci97N.png)](https://i.stack.imgur.com/ci97N.png)
Because I would have to insert 15 images here for how to reproduce this, I just uploaded the level. The level ID is 5216804. The description tells you how to run it and you can copy it since it is copyable.
**Explanation:**
The top-left trigger (Instant Count 2) checked if the first addend was 0. If it was, it then checked if the second addend was positive or negative. If it was positive, it transferred the value from the second addend to the sum (BF-style, using loops) and if it was negative, it would do the same thing.
The reason why we need to check if the second addend is positive or negative is that we would need to subtract one from the second addend and add one to the sum or add one to the second addend and subtract one from the sum respectively.
If the first addend is not zero, it tests whether it is positive or negative using the process above. After one iteration in the while loop, it tests to see if the first addend is zero and if it is, it does the process described at the beginning of the explanation.
Since Geometry Dash is remarkably similar to BF, you could make a BF solution out of this.
[Answer]
# APOL, 6 bytes
```
+(i i)
```
I AM BOT FEED ME BUTTER
[Answer]
# Mathematica, ~~4~~ 2 bytes
```
Tr
```
*Crossed out ~~4~~ is still regular 4...*
`Tr` applied to a one-dimensional list takes the sum of said list's elements.
[Answer]
# JavaScript (ES6), 9 bytes
```
a=>b=>a+b
```
[Answer]
# Haskell, 3 bytes
```
(+)
```
The parentheses are here because it needs to be an prefix function. This is the same as taking a section of the + function, but no arguments are applied. It also works on a wide range of types, such as properly implemented Vectors, Matricies, Complex numbers, Floats, Doubles, Rationals, and of course Integers.
Because this is Haskell, here is how to do it on the type-level. This will be done at compile time instead of run time:
```
-- This *type* represents Zero
data Zero
-- This *type* represents any other number by saying what number it is a successor to.
-- For example: One is (Succ Zero) and Two is (Succ (Succ Zero))
data Succ a
-- a + b = c, if you have a and b, you can find c, and if you have a and c you can find b (This gives subtraction automatically!)
class Add a b c | a b -> c, a c -> b
-- 0 + n = n 
instance Add Zero n n
-- If (a + b = c) then ((a + 1) + b = (c + 1))
instance (Add a b c) => Add (Succ a) b (Succ c)
```
Code adapted from [Haskell Wiki](https://wiki.haskell.org/Type_arithmetic)
[Answer]
# [Shakespeare Programming Language](http://esolangs.org/wiki/Shakespeare), ~~155~~ 152 bytes
```
.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
Listen to thy heart
Ford:
Listen to THY heart!You is sum you and I.Open thy heart
[Exeunt]
```
Ungolfed:
```
Summing Two Numbers in Verona.
Romeo, a numerical man.
Juliet, his lover and numerical counterpart.
Act I: In which Italian addition is performed.
Scene I: In which our two young lovers have a short chat.
[Enter Romeo and Juliet]
Romeo:
  Listen to thy heart.
Juliet:
  Listen to THY heart! Thou art the sum of thyself and I. Open thy heart.
[Exeunt]
```
I'm using [drsam94's SPL compiler](https://github.com/drsam94/Spl) to compile this. To test:
```
$ python splc.py sum.spl > sum.c
$ gcc sum.c -o sum.exe
$ echo -e "5\n16" | ./sum
21
```
[Answer]
# dc, 2 bytes
```
+f
```
Adds top two items on stack (previously taken from `stdin`), then dumps the stack's contents to `stdout`.
**EDIT:** Upon further consideration, it seems there are several ways this might be implemented, depending on the desired I/O behaviour.
```
+        # adds top two items and pushes on stack
+n       # adds top two and prints it, no newline, popping it from stack
+dn      # ditto, except leaves result on stack
??+      # takes two inputs from stdin before adding, leaving sum on stack
```
I suppose the most complete form for the sum would be this:
```
??+p     # takes two inputs, adds, 'peeks'
         #  (prints top value with newline and leaves result on stack)
```
Wait! Two numbers can be taken on the same line, separated by a space! This gives us:
```
?+p
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 2 bytes
```
+.
```
Expects a list with the two numbers as input
Alternatively, if you want the answer to `STDOUT`:
```
+w
```
[Answer]
# Python, ~~11~~ 3 bytes
```
sum
```
---
~~`int.__add__`~~
A simple special operator.
[Answer]
# [Plumber](https://github.com/Radvylf/plumber), ~~244~~ 176 bytes
```
  []  []      []
      ][=][]
  []=][][=][
[]=]===]]
][]][=[=]]    =]]
[]][   ][===[=[]
 ]][]=][[[=]=]][][
  []]=]=]=]=[]
  ][]=[]][
  []]=][=][]
= =]=]][[=[==
][=]=]=]=]===][=
```
## Old Design (244 bytes)
```
  []                []
            [][=[]
 [[=[][]  [][]  ][]][=
][[]  ][[=]]]][]=[[]
[]===][]  ][===][]
][][  []    ][  ]     [][]
      [     ][]=][[[===][[
][]]]=][[]=[=]=]=]]==]=]][
  ][=]=]]==]=][]  ][
    [][=][=[[][[=]][
   ==]=]][[=[= =
```
I thought I had a good solution for a while...except it didn't work with `0` or `1` as the first input. This program consists of three parts: incrementer, decrementer, and outputter.
The decrementer is on the left, and holds the first value. It is incremented, since a `0` would cause an infinite loop (as the program tries to decrement to `0` and gets a negative value). It will decrement the stored value at execution, and send a packet to the incrementer.
The incrementer is on the right, and stores the second input. When the decrementer sends a packet, it increments its stored value, and sends a packet back to the decrementer.
Whenever the decrementer sends the packet to the incrementer, it is checked by the outputter. If the packet is `0`, execution stops and the value of the incrementer is read and outputted. It uses a NOT gate, one of the most complicated parts of the program.
## Older design (doesn't work with some inputs), 233 bytes
```
          []          []
          [][]  [][]  =][]
    []=][]=][[=]][
      [][===][  [][===[]
[][]   [        []    ][][
] [===][=]][     ]
][[=[=[=[=[=]=[]][=[[[][
    ][[=[=[=[==[[=[=][
          []]=][=][]
        = =]=]][[=[== 
```
The new one is flipped to save bytes, and it's really confusing me. This design is the one I worked with for a week or so when designing the interpreter.
[Answer]
# Cheddar, 3 bytes
```
(+)
```
This is a cool feature of Cheddar called "functionized operators". Credit for this idea goes to @CᴏɴᴏʀO'Bʀɪᴇɴ. 
Here are more examples of functionized operators:
```
(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5
```
[Answer]
# MATL, 1 byte
```
s
```
Accepts an array of two integers as input and sums them. While the simple program of `+` also works, that has already been shown for other languages.
[**Try it Online**](http://matl.tryitonline.net/#code=cw&input=WzIgNF0)
[Answer]
# PHP, 20 bytes
Surprisingly short this time:
```
<?=array_sum($argv);
```
Runs from command line, like:
```
$ php sum.php 1 2
```
[Answer]
# [Fuzzy Octo Guacamole](https://github.com/RikerW/Fuzzy-Octo-Guacamole), 1 byte
```
a
```
A function that takes inputs from the top of the stack and outputs by pushing to the stack.
Example running in the REPL:
```
>>> 8 9 :
[8,9]
>>> a :
17
```
[Answer]
# C, 35 bytes
```
s(x,y){return y?s(x^y,(x&y)<<1):x;}
```
What I've done here is defined addition without the use of boolean or arithmetic operators. This recursively makes x the sum bits by 'xor', and y the carry bits by 'and' until there is no carry. Here's the ungolfed version:
```
int sum(int x,int y){
    if(y==0){
        //anything plus 0 is itself
        return x;
    }
    //if it makes you happier imagine there's an else here
    int sumBits=x^y;
    int carryBits=(x&y)<<1;
    return sum(sumBits,carryBits);
}
```
[Answer]
# x86\_32 machine code, 2 bytes
```
08048540 <add7>:
 8048540:   01 c8                   add    %ecx,%eax
```
Assuming the two values are already in the ecx and eax registers, performing the add instruction will add the values of the two registers and store the result in the destination register.
You can see the full program written in C and inline assembly [here](https://gcc.godbolt.org/z/WdGbEP7x4). Writing the wrapper in C makes it easier to provide inputs and do testing, but the actual add function can be reduced down to these two bytes.
[Answer]
## Perl 5.10, 8 bytes
The two numbers to add must be on 2 separate lines for this one to work:
```
say<>+<>
```
[Try this one here.](https://ideone.com/PTznrK)
One with input on the same line (**14 + 1 bytes for *-a* flag**)
```
say$F[0]+$F[1]
```
[Try it here!](https://ideone.com/6PZ9NR)
One with input on the same line (**19 + 1 bytes for *-a* flag**)
```
map{$s+=$_}@F;say$s
```
[Try this one here.](https://ideone.com/ykfi5N)
Another one, by changing the array default separator (**19 + 1 bytes for *-a* flag** as well)
```
$"="+";say eval"@F"
```
[Try this one here!](https://ideone.com/arDZIJ)
[Answer]
## Batch, ~~25~~ ~~18~~ 16 bytes
```
@cmd/cset/a%1+%2
```
Edit: saved ~~7~~ 9 bytes by using my trick from [Alternating Sign Sequence](https://codegolf.stackexchange.com/questions/80858/alternating-sign-sequence/80868#80868).
[Answer]
## PowerShell v2+, 17 bytes
```
$args-join'+'|iex
```
Takes input as two separate command-line arguments, which get pre-populated into the special array `$args`. We form a string with the `-join` operator by concatenating them together with a `+` in the middle, then pipe that string to `Invoke-Expression` (similar to `eval`).
---
Thanks to @DarthTwon for reminding me that when dealing with such minimal programs, there are multiple methods of taking input all at the same byte-count.
```
$args[0]+$args[1]
param($a,$b)$a+$b
```
PowerShell is nothing if not flexible.
[Answer]
## [><>](https://esolangs.org/wiki/fish), ~~7~~ ~~6~~ 3 bytes
```
+n;
```
[Online interpreter](https://fishlanguage.com/playground)
Or try it on TIO with the -v flag.
[Try it online](http://fish.tryitonline.net/#code=K247&input=&args=LXYgMTU+LXYgMjU)
[Answer]
# [Alchemist](https://esolangs.org/wiki/Alchemist), ~~253 211~~ 205 bytes
```
_->u+v+2r
u+r->In_a+In_x
v+r->In_b+In_y
a+b->Out_"-"
0_+0r+0d+0a+0b->d
0d+0a+x+b+y->b
0r+0d+a+0b+0y->d+Out_"-"
0r+0d+0b+a+0x->d
a+x+0b+y->a
0r+0d+0a+b+0x->d+Out_"-"
0r+0d+0a+b+0y->d
d+x->d+y
d+y->d+Out_"1"
```
Since Alchemist can't handle negative numbers (there can't be a negative amount of atoms) this takes 4 inputs on *stdin* in this order:
* sign of `x` (0 -> `+` and 1 -> `-`)
* the number `x` itself
* sign of `y` (0 -> `+` and 1 -> `-`)
* the number `y` itself
Output is in unary, [try it online!](https://tio.run/##XYyxDgIhEET7/QzaCcl69vRWfgJhxUQTtcDjAl@PLJgzsdnMzsub8Ljcrs/7e23NW5exYUmUkaw7vXxAP4W27yv6VgoQ68559cYaYg9O4AgO4N5HmrlAUK0TmlQhuBcRuzk1UVZUVImHFWjflAn/rQF0jiIGrz385g@mNaaFmI4f "Alchemist – Try It Online")
(for your convenience, [here](https://tio.run/##bVHBitswFLzrKwatKRuEKjulh1LWS9tD2UsL3eOmGNlWYoEjB0n2Jmz3213JDvG25CKe3mjmzeiV0jXjWEmPHLKutdedeV9ZQ8gNvnVmUNbD9PtSWfgO9PHh@4@N@fL1cWMo8V0h26pRe@18oc2h97hd4YUAsnR3NLlVVdMhyfAHTtVwgguxogH2ynlQijtcefSU8k@/hditKIAbJPfQDhn0FkbtpNeD@owUqnUqKE1kmtxvTBJmRlOv0fmv3uBiDc/aN/CNQtVZqyqPyavDu9CYE3a9j@63ttujN9KeYthaVXovW7IIndPN9Bjwyg8k2ep6fz1Fn9Qj9WC18dvgfVajIb/oDl5ceEv1z2KwzkWtBmH6tp0Und6ZIPgyKQuRvdJ5AUXw/2YQ50jmaG@2EernCrwKQoG0vKRhHyxYBs@RxAHJWfD8w4u18DBZj2PB854NbG1JzyzPH0whWTiOZDhfy3g9EclKnv/sfUE5JWnBUsvSmqWSpaFfk7k@spKdeF6SGY0gS0OjZhfmTCsjdozESEonliQXzXIG/2dNQJQjNZvwUygW@YyO/OP44S8 "Bash – Try It Online") is a wrapper, converting inputs and returning decimal outputs)
## Explanation & ungolfed
Since Alchemist applies the rules non-deterministically we need a lot of *0-rules*.. Initially there is only one `_` atom, so we use that to read the inputs:
```
_->u+v+2r
u+r->In_a+In_x
v+r->In_b+In_y
```
The following rules can't be applied because they all require `0r`, now we have `a`, `b` as the signs of `x` and `y` respectively.
```
# Case -x -y: we output the sign and remove a,b
# therefore we will handle them the same as +x +y
0_+0r+0d+a+b->Out_"-"        #: 0_+0r+0d ⇐ a+b
# Case +x +y: doesn't need anything done
0_+0r+0d+0a+0b->d
# Case +x -y:
## remove one atom each
0_+0r+0d+0a+x+b+y->b         #: 0_+0r ⇐ x+b
## if we had |y| > x: output sign and be done
0_+0r+0d+a+0b+0y->d+Out_"-"  #: 0_ ⇐ 0r+a
## else: be done
0_+0r+0d+0b+a+0x->d          #: 0_ ⇐ 0r+a
# Case -x +y is symmetric to the +x -y case:
0_+0r+0d+a+x+0b+y->a         #: 0_+0r+0d ⇐ a+y
0_+0r+0d+0a+b+0x->d+Out_"-"  #: 0_ ⇐ 0r+b
0_+0r+0d+0a+b+0y->d          #: 0_ ⇐ 0r+b
# All computations are done and we can output in unary:
0_+d+x->d+Out_"1"            #: 0_ ⇐ d
0_+d+y->d+Out_"1"            #: 0_ ⇐ d
```
To the right of some rules I marked some golfs with `#: y ⇐ x` which should read as: "The conditions `x` imply `y` at this stage and thus we can remove it without changing the determinism"
]