Martingale and Reverse-Martingale Simulator Program Details

I built this code, by first asking GROK AI to write a Martingale Simulator in Basic, so I could run it on my Z80, just as an experiment. It's proved so fascinating, that I found a good BASIC interpreter, called X11Basic, and built and installed it from source, on several Linux machines. The Martingale and Reverse-Martingale simulators were brought to my attention, by the blow-up of "Captain Condor" (David Chau), who on Christmas Eve, in 2025, he himself, and along with his followers, were using the "Iron Condor" options strategy, to make leveraged options bets on the SPX, when realized volatility and implied volatility were not in alignment. If their trade lost, they would triple (!) bet size, and do the trade again. I recalled the "Martingale" betting system, where a gambler doubles-down after each loss, is generally regarded as a strategy which eventually destroys gamblers. And this was the case, where the scaled-up "Iron Condor" trade lost roughly $50 million, wiping out a large number of traders who were following "Captain Condor", using this strategy.

It's really worth the time, to play with trading simulators, and try different parameters, and these two programs allow this. You can see surprising results.

The screen-shots are all from my Z80 stuff - but now, as of Feb. 7, 2026, at the page bottom, I have modern X11Basic code, for MARTGLX11.BAS (the Martingale Simulator), and REVMTGLX.BAS (the Reverse-Martingale Simulator), in plain-text. If you install the X11Basic interpreter on a Linux machine, and just copy/paste this program code into a couple of different files, you can load, run and play with these programs, and enter different initial amounts of capital, bet-size, win-probability (the trader's "edge"), and the number of trades to simulate - 1000, 10000, 100000 or whatever. The evolution of the trading (betting) action is very interesting to observe.

Update Using X11Basic Interpreter on Linux to run Simulator Programs

Ok, here an update. Look a the Research Log for Feb 7, 2026, and see how I got the X11Basic interpreter running on the Linux boxes. It's a pretty good piece of software.

Here is much improved code, which can run in the X11Basic interpreter. There are two programs, the Martingale Simulator (that will make money, but often (always?) blows up and bankrupts the simulated trader(gambler).

The second program, is the Reverse Martingale program, where you scale up on wins, not on losses. This is what rational traders do in the real world, so they don't get carried out in a basket, having lost more than all they have. (This Happens, really.)

It is the magic one, which if run with the right parameters, can make a lot of money, without almost always bankrupting the simulated trader. Play with it, and learn. Yes, the effective distribution of possible results is pretty close to gausian, but it is the sequence of runs, where the extreme conditions reside. In a Reverse Martingale, the unlikely sequence of wins is used to create the extreme gains for the trader. Most of the trading activity just grinds down the simulated trader's funds - again, much like the way the real world operates.

Here are the two X11Basic programs as plain-text (I found the html PRE operative...). They can just be copy/pasted into text file, and loaded and run with the X11Basic interpreter. See the Feb. 7th, 2026 Research Log entry for details on how to build and install the X11Basic interpreter from source, on any modern 64-bit Linux or even an old 32-bit Linux, if you have an old machine or laptop with an installed Linux distro.

 MARTGLX11.BAS
REM Martingale Simulator for X11BASIC  -- Note: This one WORKS, X11Basic uses labels, not line numbers.
REM ---------------------------------     Also, IF   ENDIF, with  and ENDIF on 
REM                                       seperate lines.  There is no "THEN" subcommand.

L05:
 PRINT " " 
 PRINT "Martingale Trading Simulation" 
 PRINT "============================="
 PRINT " "
 REM ======================================= 
 REM     Simple Martingale Trading Simulation 
 REM ======================================= 
 INPUT "Enter number to seed RND function: ";X 
 N = RND(X)
 PRINT " " 
 PRINT "MARTINGALE TRADING SIMULATION" 
 PRINT "-----------------------------" 
 PRINT " "
 INPUT "Initial Capital ($): "; CAP
 REM --- INPUT  CAP 
 PRINT "Starting bet size ($): "
 INPUT  BET 
L85: 
 PRINT "Win probability (0.5 to 0.7 typically): "
 INPUT PWIN 
 PRINT "How many trades to simulate: "
 INPUT TMXTRDS 
 PRINT "Max Trades: ", TMXTRDS 
 IF PWIN <= 0 OR PWIN >= 1
         GOTO L85
       ENDIF 
 PRINT " " 
 PRINT "Starting simulation..." 
 PRINT "Initial balance: ", CAP 
 PRINT " "
 LET BAL = CAP 
 LET CURRBET = BET 
 LET MXDRAWDN = 0 
 LET PEAK = CAP 
 LET WINS = 0 
 LET LOSSES = 0 
 LET LUNGESTLOS = 0 
 LET NCURRLOS = 0 
 LET NLOS = 0 
 LET NWIN = 0 
 REM ------- 
 FOR TRADE = 1 TO TMXTRDS 
 REM Generate random outcome (0=loss, 1=win) 
 LET R = RND(X) 
 LET X = X + 1 
 IF R <= PWIN 
     GOTO L320 
    ENDIF 
REM === LOSS === 
 LET BAL = BAL - CURRBET 
 PRINT " Trade Number: ", TRADE
 PRINT "    Loss ... and Balance: ", BAL 
 REM --- OUT 10,99 : OUT 16,99 
 LET NCURRLOS = NCURRLOS + 1 
 LET NLOS = NLOS + 1 
 GOTO L370 
L320: 
REM === WIN === 
 LET BAL = BAL + CURRBET 
 PRINT " Trade Number: ", TRADE
 PRINT "    Win .... and Balance: ", BAL 
 REM --- OUT 10,8 : OUT 16,8 
 LET WINS = WINS + 1 
 LET NCURRLOS = 0 
 LET NWIN = NWIN + 1 
 REM --- reset after win 
 LET CURRBET = BET 
L370:
 REM Track statistics 
 IF BAL > PEAK 
    PEAK = BAL 
   ENDIF 
LET DRAWDOWN = PEAK - BAL 
 IF DRAWDOWN > MXDRAWDN 
    MXDRAWDN = DRAWDOWN 
   ENDIF
 IF NCURRLOS > LUNGESTLOS 
    LUNGESTLOS = NCURRLOS 
   ENDIF
 REM Next bet size (classic Martingale) 
 IF NCURRLOS=0 
     CURRBET=BET 
   ENDIF 
 IF NCURRLOS>0 
     CURRBET=CURRBET*2 
   ENDIF
 PRINT "Current Bet: "; CURRBET 
 REM Emergency stop - bankrupt 
 IF BAL <= 0 
    GOTO L600 
   ENDIF 
NEXT TRADE 
 REM --------- 
L500:
 REM ==================== RESULTS ==================== 
 PRINT 
 PRINT "=== SIMULATION FINISHED ===" 
 PRINT "Trades completed: "; TRADE-1 
 PRINT 
 PRINT  "Final balance ........: $ ", BAL 
 PRINT  "Net profit/loss ......: $ ", BAL-CAP 
 PRINT  "Max drawdown .........: $ ", MXDRAWDN 
 PRINT  "Peak balance .........: $ ", PEAK 
 PRINT  "Return ...............: % ", (BAL-CAP)/CAP*100 
 PRINT  "Number of Losses ....:  ", NLOS 
 PRINT  "Number of Wins ......:  ", NWIN 
 PRINT  "Starting Bet .... "; BET 
 PRINT  "Win Probability   ";PWIN 
 PRINT 
 PRINT "Wins / Losses .........: ", WINS, "/", (TRADE-1)-WINS 
 PRINT "Longest losing streak .: ", LUNGESTLOS 
 GOTO L700 
L600: 
 REM Bankrupt 
 PRINT 
 PRINT "!!! BANKRUPT !!!" 
 PRINT "Stopped at trade #: ", TRADE 
 PRINT "Final balance: ", BAL 
 PRINT "Longest losing streak was: ", LUNGESTLOS 
 PRINT " "
 GOTO L500
L700: 
  PRINT 
 INPUT "Run again (Y/N): ", AGAIN$
 IF AGAIN$="Y" OR AGAIN$="y"
     GOTO L05 
   ENDIF
 END 

And now, the one that really is worth playing with, and learning about, because it uses the extreme conditions (unlikely runs of same result in a row), to benefit, not destroy, the simulated trader...

 REVMTGLX.BAS

REM --- OUT 10,56 : OUT 16,94

L05:
   PRINT " "
   PRINT "REVERSE Martingale Simulation - Increase Bet if WIN" 
   PRINT "==================================================="
   PRINT " "
   REM  REVERSE Martingale Trading Simulation - Increase Bet if Win" 
 REM =============================================================
 INPUT "Enter number to seed RND function (nn.nnnn): ";X
 N = RND(X) 
 PRINT " "
 PRINT "Reverse Martingale Simulation" 
 PRINT "-----------------------------" 
 INPUT "Initial capital ($): "; CAP 
 INPUT "Starting bet size ($): "; BET 
L90:
   INPUT "Win probability (0.4-0.6 typical): "; PWIN 
 INPUT "How many trades to simulate: "; TMXTRDS 
 INPUT "Enter BETLIMIT to trigger Bet size reset: "; BLIMIT
 PRINT "Max Trades: "; TMXTRDS 
    IF PWIN <= 0 OR PWIN >= 1 
       GOTO L90 
    ENDIF
 PRINT " " 
 PRINT "Starting simulation..." 
 PRINT "Initial balance: "; CAP 
 PRINT 
 BAL = CAP 
 CURRBET = BET 
 MXDRAWDN = 0 
 PEAK = CAP 
 WINS = 0 
 LOSSES = 0 
 LUNGESTLOS = 0 
 NCURRLOS = 0 
 NLOS = 0 
 NWIN = 0 
 REM ------- 
 FOR TRADE = 1 TO TMXTRDS 
 REM Generate random outcome (0=loss, 1=win) 
 R = RND(X) 
 X = X + 1 
 IF R <= PWIN 
       GOTO L320 
    ENDIF
 REM === LOSS === 
 BAL = BAL - CURRBET 
 PRINT "Loss ... and Balance: ", BAL, "  Trade Number: ", TRADE 
 REM --- display loss: OUT 10,99 : OUT 16,99 
 NCURRLOS = NCURRLOS + 1 
 NLOS = NLOS + 1 
 REM --- reset betsize after loss (rev. mtngl) 
 CURRBET = BET 
 GOTO L370 
L320:
    REM === WIN === 
 BAL = BAL + CURRBET 
 PRINT "Win .... and Balance: ", BAL, "  Trade Number: ", TRADE 
 REM --- display win: OUT 10,8 : OUT 16,8 
 WINS = WINS + 1 
 NCURRLOS = 0 
 NWIN = NWIN + 1 
 REM --- Do not reset after win, reset after loss (this is Rev. Mrtni)
 REM CURRBET = BET 
L370:
     REM Track statistics 
 IF BAL > PEAK 
     PEAK = BAL 
    ENDIF 
DRAWDOWN = PEAK - BAL 
 IF DRAWDOWN > MXDRAWDN 
     MXDRAWDN = DRAWDOWN
    ENDIF 
 IF NCURRLOS > LUNGESTLOS 
     LUNGESTLOS = NCURRLOS 
    ENDIF
 REM Next bet size (REVERSE Martingale) 
 IF NCURRLOS=0 
     CURRBET=CURRBET*2 
    ENDIF
 IF NCURLOSS>0 
     CURRBET=BET 
    ENDIF
 REM --- Once BETSIZE gets bigger than BETLIMIT, reset it to BET orig
 IF CURRBET > BLIMIT 
     CURRBET=BET
    ENDIF
 PRINT "Current Bet: "; CURRBET 
 REM Emergency stop - bankrupt 
 IF BAL <= 0 
      GOTO L600
    ENDIF 
 NEXT TRADE 
 REM --------- 
L500:
 REM ==================== RESULTS ==================== 
 PRINT 
 PRINT "=== SIMULATION FINISHED ===" 
 PRINT "Trades completed: "; TRADE-1 
 PRINT 
 PRINT  "Final balance ........: $ "; BAL 
 PRINT  "Net profit/loss ......: $ "; BAL-CAP 
 PRINT  "Max drawdown .........: $ "; MXDRAWDN 
 PRINT  "Peak balance .........: $ "; PEAK 
 PRINT  "Return ...............: % "; (BAL-CAP)/CAP*100 
 PRINT  "Number of Losses ....:  "; NLOS 
 PRINT  "Number of Wins ......:  "; NWIN 
 PRINT  "Starting Bet .... "; BET 
 PRINT  "Win Probability   ";PWIN 
 PRINT  "Bet Reset Limit .....: "; BLIMIT
 PRINT 
 PRINT "Wins / Losses .........: "; WINS; " / "; (TRADE-1)-WINS 
 PRINT "Longest losing streak .: "; LUNGESTLOS 
 GOTO L700 
L600:
    REM Bankrupt 
 PRINT " "
 PRINT "!!! BANKRUPT !!!" 
 PRINT "Stopped at trade #"; TRADE 
 PRINT "Final balance: "; BAL 
 PRINT "Longest losing streak was: "; LUNGESTLOS 
 PRINT " "
 GOTO L500
L700:
    PRINT " "
 INPUT "Run again (Y/N): "; AGAIN$ 
 IF AGAIN$="Y" OR AGAIN$="y" 
      GOTO L05
    ENDIF 
 END 
 

So, these two programs can be just copied into text files, and then given names and loaded into the X11Basic interpreter, and run with various parameters supplied by the user. They are really interesting and educational. Try using a starting capital of 100000, a starting bet size of 100, a slight edge (a 0.52 win probability), and either 1000 or 10000 or 100000 trades, and note how the trading action unfolds.

The simulation is driven by the results of biased randomness (a win is when the RND function returns less than or equal to the win probability number). You can check that the biased-random results of wins and losses is very close (usually) to the probability expected by the win probability value.

The magic in the "Reverse Martingale" simulation, comes partly from the value entered for the "Bet Limit", where scaled-up betting is stopped. Try a value of 50000 or even 125000, where the scale-up-bet-size on win, is stopped, and reset.