I'm using a sort of a hybrid of Mugen's default juggles and a 3-var worth series of flags in an attempt to conceive a juggle system that encourages using most of the movelist as possible to do juggles. Due to my lack of better wording chances are I may end up confusing you with how I write but at least I'll try.
For almost every attack aside of basic throws and supers (to which I have them not use up juggle points at all) I'd assign a "group" (a var for which the flags would be stored) and an "id" (the flag itself), which could be written as floor(exp(X*ln(2)) + 0.5) (where X is the id in range of 0-9). This equation actually translates to a power of 2 thus in the place of the equation you can just put in 1,2,4,8,16,32 etc., the equation's there just for the sake of easier readablitity
Spoiler: what the equations translate to: (click to see content)
floor(exp(0*ln(2)) + 0.5) = 1
floor(exp(1*ln(2)) + 0.5) = 2
floor(exp(2*ln(2)) + 0.5) = 4
floor(exp(3*ln(2)) + 0.5) = 8
floor(exp(4*ln(2)) + 0.5) = 16
floor(exp(5*ln(2)) + 0.5) = 32
floor(exp(6*ln(2)) + 0.5) = 64
floor(exp(7*ln(2)) + 0.5) = 128
floor(exp(8*ln(2)) + 0.5) = 256
floor(exp(9*ln(2)) + 0.5) = 512
Note that a couple of years ago when I tried flags higher than 512 ( say, floor(exp(10*ln(2)) + 0.5) which would translate to 1024 ) things have gotten sort of screwy from what I remember - probably based on the limit of how high the var integer can reach - which is exactly why just in case I'm using around 3 vars to store the flags.
For attacks, the statedefs have juggle points something like this (for flag detection):
juggle = ifelse(var(40) & floor(exp(1*ln(2)) + 0.5) ,1,0)
Which makes it so the particular attack uses up the juggle point only if at the start of it the flag 2 (see above) in var(40) is set (for context, the attack would use up the juggle point only if the character has already hit the opponent with said attack before in a combo)
The attacks would also have a state controller like this (for flag setting):
[State Neo-Juggle-System-Flag]
type = VarSet
trigger1 = movehit = [1,2]
trigger1 = numtarget
trigger1 = (target,statetype = A) || (target,statetype = L)
var(40) = var(40) | floor(exp(1*ln(2)) + 0.5)
ignorehitpause = 1
persistent = 0
This would set the flag 2 in var 40 when the attack hits an aerial opponent.
Of course, we should also remember to use a measure in statedef -2 that resets the vars when opponent is not in hitstate, which goes something like this (for flag resets):
[State -2, Neo-Juggle-System-Reset]
type = VarSet
triggerall = var(40)
trigger1 = !numtarget
var(40) = 0
ignorehitpause = 1
[State -2, Neo-Juggle-System-Reset]
type = VarSet
triggerall = var(41)
trigger1 = !numtarget
var(41) = 0
ignorehitpause = 1
[State -2, Neo-Juggle-System-Reset]
type = VarSet
triggerall = var(42)
trigger1 = !numtarget
var(42) = 0
ignorehitpause = 1
Because of the matter of helpers not sharing the (spent) juggle points with their owners, for projectiles I usually go for other means to limit them (like the projectile going invisible after impact and not getting "destroyed" - which would allow the projectile to be thrown again - until the opponent would leave the hitstate). That being said I did code a character (Kaf Ka from Battle Monsters) that attacks with the floating orbs that are his constant helpers and I did in fact apply the system to them as well, I just had to adjust some things - especially regarding the juggle flag reset - to make it work.