Well, there's a lot of tiny bits that make it an ugly language for me. For example, here's how we write shaders:
VERTEX_SHADER
void v_unit(
in int vertex_id : VERTEXID,
out float4 opos : POSITION,
)
{ ... }
FRAGMENT_SHADER
uint4 f_compress(
float4 fragcoord : FRAGCOORD,
uniform sampler2D image,
uniform int mip = 0
)
{ ... }
The same code in GLSL has to be split into two files, where each function is 'main', with global variables instead of the parameters, making the code more messy and less readable. Original GLSL didn't support #include (added now). In GLSL you have half-ambiguously blocks and structures, but struct cannot be used here and there. Block scope is weird. Const has an additional constraint that it can be constructed only from constant expressions, but it was so awkward that now the board allows to use it in functions in its C-like meaning. Boolean vector operators are not supported, you must use lessThan etc, but they forgot vector and/or/xor. And so on.
Then there's a lot of minor cosmetic stuff that still bothers me - vector types named as float2, int3, uint4, bool3 in DirectX or Nvidia's cg are here vec2, ivec3, uvec4, bvec3. And lots of other stuff ...
However, we wouldn't probably make the compiler just because of this. Initially we were using Nvidia's cg that is capable of compiling into various profiles, one of them glsl. Nvidia of course didn't make the profiles for ATI, and the glsl output was limited and buggy and the support miserable. So we were forced to either cross over to the glsl or to make a preprocessor. We already had some apparatus that took cg generated code and provided wrappers so that the shaders could be integrated effortlessly with the engine. Given that I have written several parsers and code generators in my life, I decided to make a cg-like compiler to glsl, that would also generate all the gluing code.
Nowadays we can just write a new shader, and immediately start using it with a single-line directive in the engine. The generator takes care of everything in between. We also enhanced the language constructs from the original cg syntax.