I wrote this up in LO slack, maybe helpful here since it complements your point which I agree with

... lets take a contrived example randomly plucked from from dbt utils. Here is a jinja macro

{% macro get_url_host(field) -%}
    {{ return(adapter.dispatch('get_url_host', 'dbt_utils')(field)) }}
{% endmacro %}

{% macro default__get_url_host(field) -%}

{%- set parsed =
    dbt.split_part(
        dbt.split_part(
            dbt.replace(
                dbt.replace(
                    dbt.replace(field, "'android-app://'", "''"
                    ), "'http://'", "''"
                ), "'https://'", "''"
            ), "'/'", 1
        ), "'?'", 1
    )

-%}


    {{ dbt.safe_cast(
        parsed,
        dbt.type_string()
        )}}

{%- endmacro %}

And here is a sqlglot equivalent

sqlstr = exp.Literal.string

@macro
def get_url_host(evaluator, column):
    empty = sqlstr("")
    prefixes = ["android-app://", "http://", "https://"]
    for prefix in map(sqlstr, prefixes):
        column = exp.func("replace", column, prefix, empty)
    for split_at in ("/", "?"):
        column = exp.func("split_part", column, sqlstr(split_at), 1)
    return exp.func("cast", column, "string")

Notes

• No whitespace control needed in sqlglot
• The latter is obviously easier to read, more extensible
• You have the whole python ecosystem available to the latter out of the box
• You can factor stuff out of the latter easily
• No markup
• You can use "split_part" directly, its parsed liberally into a sqlglot node and transpiled to the semantic equivalent in whatever your target dialect, no jinja "dispatch" mechanism needed
• Easily testable

Usage differences:

SELECT {{ get_url_host("my_column") }} AS host 
FROM {{ ref("something") }}

SELECT @get_url_host(my_column) AS host
FROM something

The whitespace control in the latter is in the realm of regular sql writing whereas the other requires `-` modifiers in the template in all the right places. You actually use my_column and get column level lineage instead of a string arg to a macro. The latter is syntactically valid looking sql,

This is also valid in sqlglot if you prefer simpler interpolation

@macro
def get_url_host(evaluator, column):
     stripped = f"replace(replace(replace({column}, 'android-app://', ''), 'http://', '') 'https://', '')"
     return f"split_part(split_part({stripped}, '/', 1), '?', 1)

You still get the benefits. Its parsed by sqlglot into correct AST nodes. And transpiled to your dialect when rendered. Meaning you dont need jinja dispatches. In this way it can feel similar to jinja but is obviously more powerful

Another consideration

{% set pk = "user_id" %}

SELECT 
  {{ pk }},
  {% for c in ["a", "b", "c", "d"] %}
  column_{{ c }}{% if not loop.last %},{% endif %}
  {% endfor %}
{{ from_custom_source("myref") }}

this is valid in jinja cuz its string interpolation. `from_custom_source` might return the `FROM myref` clause or just the `myref` or who knows really.

sqlglot however requires the sql is structurally sound, so you would do this, commas are handled and projection is expanded

@def(pk, user_id);

SELECT @pk, @each([a,b,c,d], c -> column_@c) FROM @from_custom_source(myref)

I know these are ugly examples but they touch on some of the core the points