I use PrismJS to power the code highlighting for this site, and up until now, I've been using python and glsl as the highlighting languages for GDScript & the Godot Shading Language, respectively.

Both are just close enough to their respective brethren as to be usable, but it left a lot to be desired. Although I'm not spectacular with regular expressions, PrismJS makes the actual act of adding new languages a breeze, and by using the python and glsl highlighting definitions as guides, I put together new definitions under the names gdscript and gsl.

The repo linked below contains simple instructions for modifying your PrismJS installation to include the new language definitions, and it's fairly straightforward.

Repository for Language Definitions
GDScript & Godot Shading Language for PrismJS

Here's two lengthier examples of each language, to show off the highlighting.

GDScript Example

# This code comes from a script within an example project of mine, 
# for a yet unfinished blog post, and is used because it was handy 
# and a decent lengthier snippet of GDScript.
extends Sprite

export(float) var Speed = 300

signal DrawPath

onready var Navigator = $"../Navigation2D"
onready var TargetPosition = $"../TargetPosition"

var pathToFollow = PoolVector2Array()

func _process(delta):
	moveAlongPath(delta)

func moveAlongPath(delta):

	if (pathToFollow.size() > 0):

		var deltaMove = (Speed * delta)
		var moveDistanceRemaining = moveTowardsTarget(pathToFollow[0], deltaMove)

		while (moveDistanceRemaining > 0):

			pathToFollow.remove(0)

			if (pathToFollow.size() == 0):
				emit_signal("DrawPath", pathToFollow)
				break

			moveDistanceRemaining = moveTowardsTarget(pathToFollow[0], moveDistanceRemaining)
			emit_signal("DrawPath", pathToFollow)


func moveTowardsTarget(targetPosition, amount):

	var vectorToTarget = targetPosition - global_position

	if vectorToTarget.length_squared() < (amount * amount):
		global_position = targetPosition
		return amount - vectorToTarget.length()

	global_position += vectorToTarget.normalized() * amount
	return 0

func _on_TargetPosition_TargetMoved():
	var globalToNavigatorSpace = Navigator.global_transform.inverse()

	# get_simple_path takes a start and end position, and returns a navigation path (as a PoolVector2Array).
	# All coordinates (both input and ouput) are in the local-space of the Navigation2D node. That's why we
	# convert our global-space start and end positions into Navigation2D local-space.
	#
	# Also worth noting as an implementation detail: by setting the member-variable `pathToFollow`, our
	# node will automatically start following along the path.
	pathToFollow = Navigator.get_simple_path(
		globalToNavigatorSpace.xform(global_position),
		globalToNavigatorSpace.xform(TargetPosition.global_position))

	# Convert the points in the path from Navigation2D local-space to global-space.
	for point_index in range(0, pathToFollow.size()):
		pathToFollow[point_index] = Navigator.global_transform.xform(pathToFollow[point_index])

	emit_signal("DrawPath", pathToFollow)

GSL Example

/*
    All thanks goes to Curly Brace and his Noise Shaders project, 
    which is where this example GSL code is sourced from.
    https://github.com/curly-brace/Godot-3.0-Noise-Shaders/blob/master/LICENSE
*/
shader_type canvas_item;

uniform vec2 offset;
uniform float scale:hint_range(0.5, 1000.0);
uniform float jitter:hint_range(0.0, 1.0);

// Cellular noise ("Worley noise") in 3D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.
// https://github.com/stegu/webgl-noise

// Modulo 289 without a division (only multiplications)
vec3 mod289_3(vec3 x) {
    return x - floor(x * (1.0 / 289.0)) * 289.0;
}

vec4 mod289_4(vec4 x) {
    return x - floor(x * (1.0 / 289.0)) * 289.0;
}

// Modulo 7 without a division
vec4 mod7(vec4 x) {
    return x - floor(x * (1.0 / 7.0)) * 7.0;
}

// Permutation polynomial: (34x^2 + x) mod 289
vec3 permute_3(vec3 x) {
    return mod289_3((34.0 * x + 1.0) * x);
}

vec4 permute_4(vec4 x) {
    return mod289_4((34.0 * x + 1.0) * x);
}

vec2 cellular2x2x2(vec3 P) {
    float K = 0.142857142857; // 1/7
    float Ko = 0.428571428571; // 1/2-K/2
    float K2 = 0.020408163265306; // 1/(7*7)
    float Kz = 0.166666666667; // 1/6
    float Kzo = 0.416666666667; // 1/2-1/6*2

    vec3 Pi = mod289_3(floor(P));
    vec3 Pf = fract(P);
    vec4 Pfx = Pf.x + vec4(0.0, -1.0, 0.0, -1.0);
    vec4 Pfy = Pf.y + vec4(0.0, 0.0, -1.0, -1.0);
    vec4 p = permute_4(Pi.x + vec4(0.0, 1.0, 0.0, 1.0));
    p = permute_4(p + Pi.y + vec4(0.0, 0.0, 1.0, 1.0));
    vec4 p1 = permute_4(p + Pi.z); // z+0
    vec4 p2 = permute_4(p + Pi.z + vec4(1.0)); // z+1
    vec4 ox1 = fract(p1*K) - Ko;
    vec4 oy1 = mod7(floor(p1*K))*K - Ko;
    vec4 oz1 = floor(p1*K2)*Kz - Kzo; // p1 < 289 guaranteed
    vec4 ox2 = fract(p2*K) - Ko;
    vec4 oy2 = mod7(floor(p2*K))*K - Ko;
    vec4 oz2 = floor(p2*K2)*Kz - Kzo;
    vec4 dx1 = Pfx + jitter*ox1;
    vec4 dy1 = Pfy + jitter*oy1;
    vec4 dz1 = Pf.z + jitter*oz1;
    vec4 dx2 = Pfx + jitter*ox2;
    vec4 dy2 = Pfy + jitter*oy2;
    vec4 dz2 = Pf.z - 1.0 + jitter*oz2;
    vec4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0
    vec4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1

    d1 = min(d1, d2);
    d1.xy = min(d1.xy, d1.wz);
    d1.x = min(d1.x, d1.y);
    return vec2(sqrt(d1.x));
}

void fragment() {
    vec2 n = cellular2x2x2(vec3((UV+offset)*scale, TIME));
    COLOR.rgb = vec3(n.x);
}