How to get legacy outlines back

I am working on a 2014-2017 style game, and want to have outlines, to make it look like it’s actually from 2014-2017.
Since they removed outlines completely in 2020, for whatever reasons, I can’t just simply enable them.

I have tried enabling them with scripts, but since they actually deleted the files for the outlines themselves, that didn’t work. I can’t use decals/blocks because of block sizing. I can’t use selection boxes because of distancing.

Are there any other ways I can accurately restore outlines?

9 Likes

Can you further explain, through maybe a screenshot, what you mean with “legacy outlines”?

3 Likes

He’s talking about this:

3 Likes

CrazyAlternetive provided an image.

It’s an old feature from around 2009 (I think) that got deprecated in 2019, and then fully removed in 2020.
There are no existing features that are able to recreate this (I honestly don’t know why they removed it since it takes more work and time to delete it than to just make it default to disabled)

Anyway, I really prefer having this in games, and just wanted to know how to recreate it as accurately as humanly possible.

2 Likes

you can try using Selection Boxes or Highlights, changing a few properties to get the thin and desired edges.

1 Like


This looks similar, using a lot will more than likely have a noticeable performance hit

3 Likes

It looks similar but the problem is that it has to be changed depending on the colour, and it will look like a cartoon from far away enough (not that far).

I guess if this is the closest thing then it’s all I’ve got. Thanks anyway.

I hope they re-add the legacy feature back, seeing as their reason for ‘performance hits and improved GPU’ doesn’t really excuse fully removing a feature, instead of just defaulting it to off. Roblox never makes sense with these updates.

1 Like

Was just looking for a solution for the same thing and really do hope that there is some sort of way to reenable this legacy feature, I actually really liked it!

Have you found anything that would be a suitable alternative? I am not wanting to use too many selection boxes for the potential gameplay impact.

2 Likes

I am so sorry for bumping up this thread, but I have found the solution to this problem, and as @br_cks already said, use selectionbox.

Using selectionbox with the used properties, the parts will look exactly like the ones you want, as you can see in the image.

2 Likes

Outlines getting bigger the farther you go is honestly the only difference, whereas the looks are mostly the same. I think Roblox made a fine decision except for the outlines getting thicker.

It also won’t work on things like cylinders or wedges like the original outlines did. The only way to truly make an accurate emulation is decals, which you’d need unique versions of for each individual part.

1 Like

Decals are a way but wouldn’t reincarnate it like selectionbox does.

This does not work and never has. I’ve been looking for a way to replicate outlines for literal years and the closest I’ve found is to use those line handle things.

EDIT:
Heres the image of the most refined version I made

code for it is in my reply to Visuile

4 Likes

Not true, but I fully agree it doesn’t replicate the outlines as well as it used to.

Will you be making it open source?

if i find a way to make the outlines effected by shadows and lighting

Here you go! Handy one liner to use in the console:

l=Instance.new('LineHandleAdornment'); l.Thickness=1; function handle(i,p,c,len) l1=l:Clone(); l1.CFrame=p; l1.Length=len; l1.Color3=c; l1.Adornee=i; l1.Parent=i; end v3=Vector3.new; ps={v3(0.5,0.5,0.5),v3(0.5,-0.5,0.5),v3(-0.5,0.5,0.5),v3(-0.5,-0.5,0.5),v3(-0.5,0.5,-0.5),v3(-0.5,-0.5,-0.5),v3(0.5,0.5,-0.5),v3(0.5,-0.5,-0.5)}; for i,v in workspace:GetDescendants() do if v:IsA('BasePart') then c=v.Color; c=v3(c.R,c.G,c.B); c*=0.5; c=Color3.new(c.x,c.y,c.z); s=v.Size; for i=1,4 do p=CFrame.new(ps[i]*s); handle(v,p,c,s.Z) end for i=3,6 do p=CFrame.new(ps[i]*s,ps[i]*s+v3(1,0,0)); handle(v,p,c,s.X) end for i=2,9,2 do p=CFrame.new(ps[i]*s,ps[i]*s+v3(0,1,0)); handle(v,p,c,s.Y) end end end


Fine, I’ll format it.

function handle(part, position, color, length) 
	local line = Instance.new('LineHandleAdornment')
	line.Thickness = 1
	line.CFrame = position
	line.Length = length
	line.Color3 = color
	line.Adornee = part
	line.Parent = part
end 

local v3 = Vector3.new
local positions = 
	{v3(0.5,0.5,0.5),
	v3(0.5,-0.5,0.5),
	v3(-0.5,0.5,0.5),
	v3(-0.5,-0.5,0.5),
	v3(-0.5,0.5,-0.5),
	v3(-0.5,-0.5,-0.5),
	v3(0.5,0.5,-0.5),
	v3(0.5,-0.5,-0.5)}

for i,part in workspace:GetDescendants() do 
	if not part:IsA('BasePart') or part.ClassName == 'Terrain' then continue end 
	
	local color = part.Color
	color = v3(color.R, color.G, color.B)
	color *= 0.5
	color = Color3.new(color.X, color.Y, color.Z)
	
	local size = part.Size

	for i = 1, 4 do 
		pos = CFrame.new(positions[i] * size)
		handle(part, pos, color, size.Z) 
	end 
	
	for i = 3, 6 do 
		pos=CFrame.new(positions[i] * size, positions[i] * size + v3(1,0,0))
		handle(part, pos, color, size.X) 
	end 
	
	for i = 2, 9, 2 do 
		pos=CFrame.new(positions[i] * size, positions[i] * size + v3(0,1,0))
		handle(part, pos, color, size.Y) 
	end 
end

I don’t know if i’d reccomend this method though, just for the fact it spawns 12 LineHandles for every single part. It’s incredibly laggy with just 8 classic houses (4.5k parts)

Maybe you can optimize this with occlusion culling, I don’t want to add it.

It also seems to not work great in shadow, as charlie said.

1 Like

i created a script a while back that just adds box outline decals to every part
its very inaccurate but looks close enough

if there is something to improve about this is probably to change the decal based on the size of the part for consistent outline sizes

this also emulates the weird color shift thing although thats also inaccurate because the colors are not completely random

2 Likes

Bump. I have a theory that’ll help us mostly revive this removed feature whilst also optimizing some of the previous ideas from their lag issues. That being said, the method I’m proposing is still laggy.

I took a crack at it myself and got some pretty good results using SelectionBoxes, but it has its fair share of issues. The vanilla outlines originally only really showed up when interacting with another part, and if you looked at a part with outlines, you wouldn’t see any outlines on the outer edges, only the colliding edges and inner edges.

SelectionBoxes don’t work this way however so they cause this constantly and ruin the aesthetic a bit, so I believe LineHandleAdornments may work better for this because you could use perspective rendering with the players camera alongside BasePart:GetTouchingParts() to accurately display them and limit the amount of them on your screen at once.

This would also greatly help with performance whilst giving a mostly 90% accurate result as well, atleast one far better than what has been achieved thus far. BasePart:GetTouchingParts() may drop some performance in certain scenarios but its well worth it, although you can just go without it for slightly less accuracy.

This would take a lot of coding and some funky calculations but would ultimately be worth it. I may take a crack at this soon but I am quite alright with the result I got from just using selectionboxes and camera distance checks to make it seem like the outlines arent getting bigger by making them become more transparent the further you are. Its not perfect, it looks a bit weird, but its decently accurate. Heres what that looks like:

image

WireframeHandleAdornments could work, too. I think.