UTAH OUTDOOR ADVENTURE TRAVEL and UTAH VACATIONS by UTAH OUTVENTURES! TRAVEL UTAH! - Click to contact us
UOV layout top
Left Nav Img
Nav Top Img

 

 

 

 

 

 

 

 

 

 

 

 

 

Todays Date:
 
Travel News, Discounted Tours, Specials - Sign Up for Our:
 
Add This Page To Your Favorites
 
Valid HTML 4.01 Transitional

 

 

We Operate Year Round - Contact Us Today!

Nav Right Img
Nav Body Top

Utah Outventures OUTDOOR GEAR SHOP - We have teamed up with the foremost outfitters to bring you the highest quality gear at competitive prices. Utah Outventures staff utilizes the gear we sell. bringing it to test every day out in the field, we know you will find what you are looking for, knowing that you bought the right gear from the right place.

SkI: To some a sport, to others a lifestyle. The most cutting edge tools you need to ski up, down, or across the mountain are all here.

CLOTHING: Nothing can ruin a day in the backcountry faster than not having the right clothing. After countless hours of gear testing, we've selected the best in technical wear & casual clothing from industry leaders.

CAMP / HIKE: Sunrise over a high alpine lake. A trek in the mountains. Pitching a tent far from the city...the backcountry beckons. After years of fieldwork, we've compiled the most technical, high-quality camping, backpacking & hiking gear by Kelty, Lowa, MSR, The North Face and more.

TRAVEL: Not everyone who wanders is lost. Explore, experience, engage. Herein lie the tools to keep you packed & organized, safely hydrated, and on the trail…when you want to be. Choose from Eagle Creek, Jansport, The North Face, Katadyn and more.

 
Men's Clothing
Women's Clothing
Camp/Hike
Bike
Climb
Travel
Kids'
Trail Run
Ski
Snowboard
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