You can try making your own. The specification is available from their website: http://www.frecle.net/download/glsspecs.htm

I did a quick search and found this one. It's written in C++. I didn't take a deeper look, but maybe it won't be that much hassle to convert it to Pascal.

EDIT
It shouldn't be too hard to convert it. I started it, but was a little busy to study the specs in detail. I didn't test the code, but it compiles under D2010. Here's what I've got so far:
[code=delphi]
type
{ .: TGiles :. }
TGiles = class sealed(TObject)
strict private
{ Strict private declarations }
type
{ .: TGLSChunk :. }
TGLSChunk = record
ID: Integer;
Size: Integer;
end;

{ .: TGLSHeader :. }
TGLSHeader = record
S: AnsiString;
Version: Single;
end;

{ .: TGLSAuthor :. }
TGLSAuthor = record
S: AnsiString;
end;

{ .: TGLSLightmap :. }
TGLSLightmap = record
Name: AnsiString;
FileName: AnsiString;
Width: Word;
Height: Word;
NonUniform: Boolean;
UseCustomTexels: Boolean;
CustomTexelSize: Single;
Repack: Boolean;
Data: array of Byte;
end;

{ .: TGLSTexture :. }
TGLSTexture = record
FileName: AnsiString;
ScaleU: Single;
ScaleV: Single;
OffsetU: Single;
OffsetV: Single;
Angle: Single;
Flags: Integer;
Blend: Integer;
CoordSet: Byte;
end;
private
{ Private declarations }
Data: array of Byte;
Offset: DWORD;
FileSize: Integer;
FFileAuthor: AnsiString;

procedure ReadHeader(Header: TGLSHeader);
procedure ReadHeaderSubChunks();
procedure ReadAuthorChunk();
procedure ReadModelsChunk();
procedure ReadModelData();

function ReadString(): AnsiString;
function ReadFloat(): Single;
function ReadChunk(): TGLSChunk;
public
{ Public declarations }
constructor Create(const AFileName: String);

property FileAuthor: AnsiString read FFileAuthor;
end;

{ TGiles }

constructor TGiles.Create(const AFileName: String);
var
FS: TFileStream;
Header: TGLSHeader;
begin
inherited Create();

FS := TFileStream.Create(AFileName, fmOpenRead);
try
Offset := 0;
FileSize := FS.Size;

SetLength(Data, FileSize);
FS.Read(Data[0], FileSize);
finally
FS.Free();
end;

ReadHeader(Header);
end;

procedure TGiles.ReadAuthorChunk;
begin
FFileAuthor := ReadString();
end;

function TGiles.ReadChunk: TGLSChunk;
begin
CopyMemory(@Result, @Data[Offset], SizeOf(TGLSChunk));
Offset := Offset + SizeOf(TGLSChunk);
end;

function TGiles.ReadFloat: Single;
begin
Result := 0.0;

CopyMemory(@Result, @Data[Offset], SizeOf(Single));
Offset := Offset + SizeOf(Single);
end;

procedure TGiles.ReadHeader(Header: TGLSHeader);
var
Chunk: TGLSChunk;
begin
Chunk := ReadChunk();

if (Chunk.ID = $FFFF) then
begin
Header.S := ReadString();
Header.Version := ReadFloat();
end;
end;

procedure TGiles.ReadHeaderSubChunks;
var
Chunk: TGLSChunk;
begin
while True do
begin
Chunk := ReadChunk();

case Chunk.ID of
$F000:
ReadAuthorChunk();
$1000:
ReadModelsChunk();
end;
end;
end;

procedure TGiles.ReadModelData;
begin

end;

procedure TGiles.ReadModelsChunk;
var
Chunk: TGLSChunk;
begin
while True do
begin
Chunk := ReadChunk();

if (Chunk.ID = $1001) then
ReadModelData()
else
begin
Offset := Offset - SizeOf(TGLSChunk);
break;
end;
end;
end;

function TGiles.ReadString: AnsiString;
var
StrLength, StrOffset: Integer;
C: AnsiChar;
begin
Result := '';
StrLength := 0;
StrOffset := Offset;
C := #0;

while True do
begin
C := AnsiChar(Data[StrOffset]);
Inc(StrOffset);
Inc(StrLength);

if (C = #0) then
break;
end;

SetLength(Result, StrLength);
CopyMemory(@Result[1], @Data[Offset], StrLength * SizeOf(AnsiChar));
Offset := Offset + (SizeOf(AnsiChar) * StrLength);
end;
[/code]
Hopefully you can expand it and use it in your work.