AWK -vRS=(.), 37 bytes

RT~/+/{x++}RT~/-/{printf"%c",x--%256}

Attempt This Online!

Uses a regex as a record seperator to split the input into seperate characters and matches them one-by-one.

Perl 5 + -p055, 24 bytes

-2 bytes thanks to @Neil!

$-+=y/+//;$_=chr$---%256

Try it online!

Explanation

Cheesing a little on the args, using -055 to split input on - and using y/+// to count the +s (ignoring other chars, thanks @Johnathan Allan!).

Pip, 29 25

C{i+:Dai+1%:256}M#*H:a^'-

- 4 bytes thanks to DLosc

Attempt This Online!

C{i+:Dai+1%:256}M#*H:a^'-­⁡​‎⁠⁠‎⁡⁠⁢⁢⁢‏⁠‎⁡⁠⁢⁢⁣‏⁠‎⁡⁠⁢⁢⁤‏⁠‎⁡⁠⁢⁣⁡‏⁠‎⁡⁠⁢⁣⁢‏⁠‎⁡⁠⁢⁣⁣‏⁠‎⁡⁠⁢⁣⁤‏⁠‎⁡⁠⁢⁤⁡‏‏​⁡⁠⁡‌⁢​‎⁠‎⁡⁠⁢‏⁠⁠⁠⁠‎⁡⁠⁤⁤‏⁠‎⁡⁠⁢⁡⁡‏⁠‎⁡⁠⁢⁡⁢‏⁠‎⁡⁠⁢⁡⁣‏⁠‎⁡⁠⁢⁡⁤‏⁠‎⁡⁠⁢⁢⁡‏⁠⁠⁠‏​⁡⁠⁡‌⁣​‎⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‏​⁡⁠⁡‌⁤​‎⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠⁠⁠‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌­
                     a^'-  # ‎⁡Split input by "-"
 {             }M#*H:      # ‎⁢Map through lengths of all but last item as a...
  i+:Da                    # ‎⁣ Increment i (initialised to 0) by length of a - 1
       i+1%:256            # ‎⁤ Return i+1 mod 256
C                          # ‎⁢⁡Convert codepoints to ASCII
💎

Created with the help of Luminespire.

JavaScript (Node.js), 57 bytes

Expects an array of characters and returns a string.

s=>Buffer(s.flatMap(c=>c=="-"?a--:(a+=c=="+",[]),a=0))+""

Try it online!

Funge-98, 47 bytes

>~#<:'+w$:'U3*-3jc+1_$0
^#:w-' <j7-1_$'U3*4j6:,

Try it online!

The program never halts, so if you run it using TIO, you have to manually cancel execution in order to view the output.

Uiua 0.11.0, 26 bytes ^SBCS

▽:+@\0◿256\+-⬚0↻¯1,∩=@+,@-

Try on Uiua Pad!

Takes a string of + and - and returns the output string. If the input is guaranteed to only contain +-, we can save 2 bytes by replacing ∩=@+,@- with ¬.=@- (and probably more, with a completely different strategy).

Explanation

@-    # push literal character - to stack
@+,   # dup input to top and push +
∩=    # get two arrays with 1s where + and - are
,     # dup the - array to top
⬚0↻¯1 # shift 1 to the left, filling with 0 at front
-     # subtract from the + array
\+    # plus scan: cumulative sums
◿256  # mod 256
+@\0  # add literal character null, converts to ASCII
▽:    # flip the - array to top and apply mask

Perl 5 -p, 35 bytes

s/.*?-/$x+=$&=~y-+--;chr$x--%256/ge

Try it online!

05AB1E, 18 15 14 bytes

'-¡'+QO<ηO>₁%ç

-3 bytes thanks to @IvanG.
-1 byte porting @JonathanAllan's Jelly answer

I/O as a list of characters.

Try it online or verify all test cases.

Explanation:

'-¡           '# Split the (implicit) input-list of characters on "-"
   '+Q        '# Check for each inner character whether it equals "+"
      O        # Sum each inner list of 1s and 0s together
       <       # Decrease each sum by 1
        η      # Get the prefixes of this list of sums-1
         O     # Sum each prefix
          >    # Then increase each prefix-sum by 1
           ₁%  # Modulo-256
             ç # Convert each integer to a character with this codepoint
               # (after which the list of characters is output implicitly as result)

Vyxal 3, 14 bytes

'-sᵛ'+Cv@₇%ꜝOṪ

Try it Online!

would be 14 if vyxal didnt automatically treat + as a regex symbol

Edit-- Bug was fixed

Google Sheets, 93 bytes

=SORT(JOIN(,IFNA(CHAR(SCAN(,SPLIT(A1,"-",,),LAMBDA(a,c,MOD(a+LEN(c),256)))-COLUMN(A:ZZ)+1))))

Lua, 149b

Read a character from standard in, and look it up in a table of two functions - call empty function otherwise.

a=0;while 1 do(({["+"]=function()a=(a+1)%256;end,["-"]=function()io.write(string.char(a))a=a<1 and 255 or a-1 end})[io.read(1)]or function()end)()end

Lua, 109b

Read character from stdin, convert to an increment, decrement, or zero, from a table. If we're going to decrement, convert accumulator number to char and print it out before adding.

a=0;while 1 do c=({["+"]=1,["-"]=-1})[io.read(1)]or 0;io.write(c<0 and string.char(a)or"")a=(a+c+256)%256;end

Charcoal, 19 bytes

⭆⌕ＡΦＳ№+-ι-℅﹪⁻ι⊗κ²⁵⁶

Try it online! Link is to verbose version of code. Explanation:

    Ｓ               Input string
   Φ                Filtered where
      +-            Literal string `+-`
     №              Contains
        ι           Current character
 ⌕Ａ                 Find all indices of
         -          Literal string `-`
⭆                   Map over indices and join
             ι      Index of current `-`
            ⁻       Minus
               κ    Count of previous `-`s
              ⊗     Doubled
           ﹪        Modulo
                ²⁵⁶ Literal integer `256`
          ℅         Convert to character
                    Implicitly print

Scala 3, 123 bytes

A port of @none1's JavaScript answer in Scala.

Golfed version. Attempt This Online!

p=>{var o="";var x=0;for(i<-p){i match{case'+'=>x+=1;if(x==256)x=0 case'-'=>o+=x.toChar;x-=1;if(x== -1)x=255;case _ =>}};o}

Ungolfed version. Attempt This Online!

object Main {
  def plusOrMinus(program: String): String = {
    var output = ""
    var x = 0
    for (i <- program) {
      i match {
        case '+' =>
          x += 1
          if (x == 256) x = 0
        case '-' =>
          output += x.toChar
          x -= 1
          if (x == -1) x = 255
        case _ => // handle other characters if necessary
      }
    }
    output
  }

  def main(args: Array[String]): Unit = {
    val input = 
s"""++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++-++++++++-+-++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++-++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-"""


    println(plusOrMinus(input))
  }
}

Stax, 15 bytes

Ç¿₧Δ─Θî²1%≤{‼aù

Run and debug it

JavaScript, 125 111 109 Bytes

r=>{f="",u=0;for(n of r)"+"==n?256==++u&&(u=0):"-"==n&&(f+=String.fromCharCode(u),-1==--u)&&(u=255);return f}

Ungolfed version:

function plusorminus(program){
    var output='',x=0;
    for(let i of program){
        if(i=='+'){
            x++;if(x==256){x=0}
        }else if(i=='-'){
            output+=String.fromCharCode(x);x--;if(x==-1){x=255}
        }
    }
    return output
}

You can run the code in this snippet:

y=r=>{f="",u=0;for(n of r)"+"==n?256==++u&&(u=0):"-"==n&&(f+=String.fromCharCode(u),-1==--u)&&(u=255);return f}
console.log(y('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++-++++++++-+-++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++-++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-'))
console.log(y('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++-++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-'))
console.log(y('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------'))
console.log(y('blah'))
console.log(y('+++++++++++++++++++++++++++++++++?-'))
console.log(y('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-++'))
console.log(y('++++++++++++++++++++++++++++++++++--'))

Python, 100 Bytes

lambda x:''.join(chr(x[:i].count('+')-x[:i].count('-')&255)if x[i]=='-'else''for i in range(len(x)))

Both the argument and the return value are strings.

Explanation: + and other characters don't produce any output, the value that a - outputs equals to the number of + minus the number of - before it modulo 256.

Try it online!

C (gcc), 49 47 46 bytes

c;f(char*s){for(;*s;)*s++%5?c++:putchar(c--);}

Pretty straightforward.

-1 byte thanks to Arnauld.

Try it online!

Pascal, 158 B

The implementation‑defined set of char values must correspond to ASCII and the ordinal value of the implementation‑defined constant maxChar must be greater than or equal to 255.

program P(input,output);var C:char;A:0‥255;begin
A≔0;while not EOF do begin
read(C);if C='−' then write(chr(A));A≔(A+ord(C='+')−ord(C='−'))mod 256 end end.

−3 B: If you have a processor supporting “Extended Pascal” as defined by ISO standard 10206, you may write a zero‑width string:

program P(input,output);var C:char;A:0‥255;begin
A≔0;while not EOF do begin
read(C);write(chr(A):ord(C='−'));A≔(A+ord(C='+')−ord(C='−'))mod 256 end end.

Users of the FreePascal Compiler need to insert a {$modeSwitch ISOMod+} compiler directive. This ensures an ISO‑compliant definition of the mod operator, in particular in case of negative dividends the result is still non‑negative (Euclidean‑like definition of mod).

Python 3, 66 bytes

v=0
for c in input():v%=256;v+=c=='+';v-='-'==c!=print(end=chr(v))

A full program that reads from stdin and prints to stdout.

Try it online! Or see the test-suite.

YASEPL, 76 75 59 bytes

=a=i=1'=l®1`1!r¥i,1}7,plus,2!+`2}7,minus,3!›-`3%256!i+}2,l

brainfuck, 65 57 bytes

>,[>--[++++++<->]+<[--[[-]>-<]>[<<.->>-][-]<]>[-<<+>>]<,]

Try it online!

Kotlin, 76 bytes

{fold(0){a,c->when(c){'-'->{print(a.toChar());a-1}'+'->a+1 else->a}and 255}}

Try it online!

-1 byte thanks to ceilingcat.

C#, 102 100 bytes

-2 thanks to @ceilingcat's suggestion to replace '+' and '-' with their ASCII codes (43 and 45)

void I(string s){byte b=0;foreach(var c in s)System.Console.Write((char)(c==43?++b-b:c==45?b--:0));}

Try it online!

Explanation:

void InterpretPlusOrMinus(string input)
{
    byte b = 0; // initialize accumulator 'b'

    foreach (var c in input)
    {
        System.Console.Write((char)( // Print the ASCII representation of:
            (c == 43)?         // If c is '+':
                 ++b - b :      //    ++b-b (increment b and return 0)
                 (c == 45)?    // Else If c is '-':
                     b-- :      //    b--
                     0          // Else: 0
        ));
    }
}

This code works in .NET 5+

PowerShell Core, 41 bytes

switch($args){+{$c++}-{[char]($c--%256)}}

Try it online!

Function that takes a string using splatting
Returns an array of characters

J, 37 bytes

[:(]#a.{~256|[:+/\[-_1|.!.0])/'+-'=/]

Shameless port of Tbw's amazing Uiua answer.

Attempt This Online!

[:(]#a.{~256|[:+/\[-_1|.!.0])/'+-'=/]
                                    ]   NB. input
                              '+-'      NB. string literal of ops
                                  =/    NB. equality table of each op and input
[:                                      NB. cap forces f(g(x)) instead of a hook
  (                         )/          NB. fold, the two table rows become left/right arg
                           ]            NB. list of chars equal to -
                    _1|.!.0             NB. shift right 1 and fill with 0
                  [                     NB. list of chars equal to +
                   -                    NB. subtract
             [:+/\                      NB. prefix sums (sum-reduce(+/) on all prefixes)
         256|                           NB. mod 256
     a.{~                               NB. index into the ascii alphabet
   ]                                    NB. list of chars equal to -
    #                                   NB. copy with boolean vector acts as a filter

Japt -hP, 20 bytes

q-
ÆËo+ ÅÊÃåÄ ËuG² d

Try it

q-\nÆËo+ ÅÊÃåÄ ËuG² d     :Implicit input of string U
q-                        :Split on "-"
  \n                      :Reassign to U
    Æ                     :Modify last element
     Ë                    :  Map remaining elements in U
      o+                  :    Keep only "+"s
         Å                :    Slice off first character
          Ê               :    Length
           Ã              :  End map
            å             :  Cumulatively reduce by
             Ä            :    Addition, after prepending a 1
               Ë          :  Map
                u         :    Modulo
                 G        :      16
                  ²       :      Squared
                    d     :    Character at that codepoint
                          :Implicit output of last element joined to a string

C (gcc), 59 bytes

char i;f(char*c){i+=*c==43;*c==45&&putchar(i--);f(c+!!*c);}

Ungolfed:

char i; // the counter
/*implicit int here */ f (char* c) {
    // increment the counter if *c is '+' (43), since == returns 1 for true
    i += *c == 43;
    // if c is not '-' (45), the condition will short circuit, otherwise putchar will run
    *c == 45 && putchar(i--);
    // if *c is the end of the string (0), !!*c will be 0, 
    // and the function will enter an infinite loop that does nothing, 
    // otherwise we will call f with a ptr to the next character.
    f(c + !!*c);
}

This handles non +/- characters properly, unlike the other C answer, however it does either hang indefinitely or overflow the stack (fixing this costs a byte). This also requires the -funsigned-char flag to run properly.

Try it online!

BrainChild, 97 bytes

function(int l,@int s){int a=0;int i=0;while(i<l){if(s[i]==43)a++if(s[i++]==45)putchar(a--%256)}}

Takes input as a char array

Readable

function PlusMinus(int length, @int chars){
    int acc=0;
    int i=0;
    while(i<length){
        if(chars[i]=='+')
            acc++
        if(chars[i++]=='-')
            putchar((acc--)%256)
    }
}

Try It Online!