All stacks are basically the same, so I'll describe the one native to z80 processors. Think of the stack like a Pez dispenser. You push data onto the stack and it is saved to a byte in RAM in front of everything else on the stack. When you pop it, it's removed from that byte in Last in, First out order.
***********
*Byte that data will be pushed into
*last filled byte of stack. Second byte to be popped
*Second to last byte
*....
*Second byte to stack. Second to last byte that will be popped.
*First byte of stack
***********

Let's say that the stack consists of several bytes, say

04
03
02
01
00

If you were to Push $05 onto the stack, then it would look like

05
04
03
02
01
00

If you were to Pop the original stack into H, then it'd place the value $04 in H and the stack would look like

03
02
01
00


So as a visual example, with the gui functions of DCSB libs, when you create a window or text box, it gets pushed on, and you pop it off to remove it from the screen basically?

So its pretty much a place to store data if you need to store it LIFO and it isnt entirely necessary for all programs except for calling and returning from functions?

Ah ok. so i should probably get better at z80 before using stacks too much since i wont be doing much complex math until i start making games and whatnot haha

Thank you Graph.

I think im gonna have to learn assembly a bit better (im a total noob) before i start trying to implement this too much. Thanks for explaining it to me guise

Be very careful with the stack though because the "push" and "pop" commands use the same stack as the "call" and "ret" instructions.  So if you call a routine, push something, and then return, you will crash the calculator since the ret is now returning to the address you pushed instead of the return address.  Same thing can happen with pop.  Make sure you match the number of pushes with the number of pops until you feel advanced enough to exploit some of those tricks.  This was my biggest source of bugs when I first started learning z80.

___Stack___

Main:   call Routine MainReturn:   pop hl   ret Routine:   push hl   ret

___Stack___    MainReturn

Main:   call Routine MainReturn:   pop hl   ret Routine:   push hl   ret

___Stack___    MainReturn    HL

Main:   call Routine MainReturn:   pop hl   ret Routine:   push hl   ret

___Stack___    MainReturn    HL

The error here is that when it gets to the return, its returning to the address HL instead of the place right after the call like it should.  So whatever random address HL holds will be jumped to and likely crash the calculator.  So you CANNOT write subroutines that push or pop arguments.  There actually is a way to do this though using a callback in case you're curious.  This one uses the ix register.

Main:
  call PushStuff
  ret

PushStuff:
  pop ix
;Do any pushing or popping you need here:
  push hl
  push bc
  push de
;Then use this instead of a return:
  jp (ix)