Yep. Or at least broadly the family of S-exp based languages. I've developed a (still closed source) Lisp dialect that has grown to what I believe to be the most(?) expressive and powerful programming language available today. As in, there is zero reason to ever pull out C/C++/Rust. It's fully compiled, with a system Fω typesystem, inductive types, and most importantly as of recently full whole program reflection. As in Lisps macro system extended to the further possible development. You can, quite literally in the language itself, define full compiler passes, manipulate the SSA, add/remove/analyze nodes.

   (module reflection_symbolic)

   (comptime
     (fn sx-kind (x k) (sym= (syntax-kind x) k))
     (fn sx-zero (x) (equal x '0.0))
     (fn sx-one (x) (equal x '1.0))
     (fn sx-add (a b)
       (cond ((sx-zero a) b) ((sx-zero b) a) (otherwise `(f+ ,a ,b))))
     (fn sx-neg (a) (if (sx-zero a) a `(fneg ,a)))
     (fn sx-sub (a b)
       (cond ((sx-zero b) a) ((equal a b) (syntax 0.0)) (otherwise `(f- ,a ,b))))
     (fn sx-mul (a b)
       (cond ((or (sx-zero a) (sx-zero b)) (syntax 0.0))
             ((sx-one a) b) ((sx-one b) a) (otherwise `(f* ,a ,b))))
     (fn sx-div (a b)
       (cond ((sx-zero a) (syntax 0.0)) ((sx-one b) a) (otherwise `(f/ ,a ,b))))
     (fn sx-id (a b)
       (if (and (syntax-binding a) (syntax-binding b))
         (= (syntax-binding a) (syntax-binding b)) (sym= a b)))
     (fn sx-lookup (x names vals)
       (if (= (len names) 0) x
         (if (sx-id x (head names)) (head vals) (sx-lookup x (tail names) (tail vals)))))
     (fn sx-map (xs names vals depth)
       (if (= (len xs) 0) (list)
         (const (sx-expand (head xs) names vals depth) (sx-map (tail xs) names vals depth))))
     (fn sx-expand (e names vals depth)
       (if (> depth 32) (syntax-error "symbolic expansion exceeds 32 nested helper calls" e)
         (cond
           ((sx-kind e 'symbol) (sx-lookup e names vals))
           ((not (sx-kind e 'list)) e)
           (otherwise
             (let ((xs (syntax-children e)))
               (let ((op (head xs)))
                 (cond
                   ((or (sym= op 'let) (sym= op 'let*))
                     (let ((ns names) (vs vals) (bs (syntax-children (nth xs 1))))
                       (declare (mutable ns vs))
                       (dotimes (i (len bs))
                         (let ((b (syntax-children (nth bs i))))
                           (let ((v (sx-expand (nth b 1) (if (sym= op 'let*) ns names)
                                             (if (sym= op 'let*) vs vals) depth)))
                             (set ns (const (head b) ns)) (set vs (const v vs)))))
                       (if (/= (len xs) 3) (syntax-error "symbolic let requires one pure body expression" e)
                         (sx-expand (nth xs 2) ns vs depth))))
                   ((sym= op 'the) (sx-expand (nth xs 2) names vals depth))
                   ((or (sym= op 'f+) (sym= op 'f-) (sym= op 'f*) (sym= op 'f/)
                        (sym= op 'fneg) (sym= op 'fsin) (sym= op 'fcos) (sym= op 'fsqrt)
                        (sym= op 'tuple) (sym= op 'vec3))
                     `(,op ,@(sx-map (tail xs) names vals depth)))
                   (otherwise
                     (let ((f (fn-ref op)))
                       (if (/= (len (fn-params f)) (- (len xs) 1))
                         (syntax-error "symbolic helper call has wrong arity" e)
                         (sx-expand (fn-body f) (syntax-children (fn-params f))
                           (sx-map (tail xs) names vals depth) (+ depth 1))))))))))))
     (fn sx-diff (e x)
       (cond
         ((or (sx-kind e 'float) (sx-kind e 'integer)) (syntax 0.0))
         ((sx-kind e 'symbol) (if (sx-id e x) (syntax 1.0) (syntax 0.0)))
         ((sx-kind e 'list)
           (let ((cs (syntax-children e)))
             (let ((op (head cs)) (a (nth cs 1)))
               (let ((da (sx-diff a x)))
                 (cond
                   ((sym= op 'fneg) (sx-neg da))
                   ((sym= op 'fsin) (sx-mul `(fcos ,a) da))
                   ((sym= op 'fcos) (sx-neg (sx-mul `(fsin ,a) da)))
                   ((sym= op 'fsqrt) (sx-div da (sx-mul (syntax 2.0) `(fsqrt ,a))))
                   ((= (len cs) 3)
                     (let ((b (nth cs 2)))
                       (let ((db (sx-diff b x)))
                         (cond ((sym= op 'f+) (sx-add da db))
                               ((sym= op 'f-) (sx-sub da db))
                               ((sym= op 'f*) (sx-add (sx-mul da b) (sx-mul a db)))
                               ((sym= op 'f/) (sx-div (sx-sub (sx-mul da b) (sx-mul a db)) (sx-mul b b)))
                               (otherwise (syntax-error "cannot differentiate this operator" op))))))
                   (otherwise (syntax-error "cannot differentiate this expression" e)))))))
         (otherwise (syntax-error "cannot differentiate this syntax" e))))
     (fn sx-partial (f index)
       (let ((e (sx-expand (fn-body f) (list) (list) 0)))
         (fn-with f 'body (sx-diff e (nth (fn-params f) index))))))

   (macro derive-partial
     (syntax-rules ()
       ((_ result source index)
         (fnderive result source (transform (lambda (f) (sx-partial f index)))))))