We'd make a small preamble to define new names for things like DEFUN, Lisp's operator to define new functions. No F's needed to do that either. We can do this by taking advantage of read-time evaluation.

First we get references to the symbols DEFMACRO and DEFUN.

    (eval-when (:compile-toplevel :load-toplevel :execute)
      (setq de*un (intern (map 'string 'code-char '(68 69 70 85 78))))
      (setq de*macro (intern (map 'string 'code-char '(68 69 70 77 65 67 82 79)))))

Now, to make life-without-F easy, we define new names for DEFMACRO (mac) and DEFUN (proc) without actually lexically referring to the F-infected symbols:

    (#.de*macro mac (&body r) `(,de*macro ,@r))
    
    (mac proc (&body r) `(,de*un ,@r))

    (proc *ib (n)
      (cond
        ((= 0 n) 0)
        ((= 1 n) 1)
        (t (+ (*ib (- n 1)) (*ib (- n 2))))))

    > (print (*ib 10))
    55

I haven't seen any non-lisp languages that give you that kind of power, for better or worse.

How about searching for all symbols with the letters DEMACRO that are 8 letters long? We could do that too.

The technique works so long as you can uniquely determine the symbol through some combination of standard Lisp functions that don't contain F. Lisp has a big library, so it's not tough.

"70" isn't a number that is associated to F in any common person's understanding, and the pronunciation of the number "70" in English has no objectionable F sounds, so I don't agree it's cheating. :)

And somehow, my reply managed to avoid using that letter ...

rimshot

The if/elseif keywords are off the table, but you still have both explicit looping constructs and function declarations:

    while x ... end
    each x y z in w ... end
    on name x y do ... end

Most of the query forms (select, extract, and update expressions) would be OK, but they all need a "from" clause to specify the source table, so no dice.

What you're left with is still very much Turing-Complete, but much less ergonomic.

[0] http://beyondloom.com/tools/trylil.html

“Mapping from source file (other than a UTF-8 source file)(since C++23) characters to the basic character set(until C++23)translation character set(since C++23) during translation phase 1 is implementation-defined, so an implementation is required to document how the basic source characters are represented in source files.”*

⇒ pre C++23, you could have a C++ compiler that used an Unicode “Pile of poo” (https://www.unicode.org/L2/L2017/17407-frowning-poo.pdf) instead of the letter F.

I think I could write an arbitrarily complex program without major issue.

    if (x) { y; } → while (x) { y; break; }
    for (a; b; c) { d; } → a; while (b) { d; c; }

    #include <stdio.h>

    int main() {
            int a = 1;
        
            switch(a) case 1: puts("there's always this");
    }

ihatetheletterf.h:

    #define cond if
    #define loop for
    #define otherwise default
    #define untrue false
    #define real float

What's convoluted about it? A `for` is about as simple as syntactic sugar gets.

    for( a; b; c ) {
    }

    a;
    while( b ) {
      c;
    }

per x in y: